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

package/dist/esm/sdk/accounts/bots/AccountBotsService.js

@@ -0,0 +1,131 @@
+import { iBotListV310Abi } from "../../../abi/310/generated.js";
+import { AP_PERIPHERY_COMPRESSOR } from "../../constants/address-provider.js";
+import { VERSION_RANGE_310 } from "../../constants/versions.js";
+import "../../constants/index.js";
+import { SDKConstruct } from "../../base/SDKConstruct.js";
+import "../../base/index.js";
+import { iBotAbi } from "./abi.js";
+import { PeripheryCompressorV310Contract } from "./PeripheryCompressorV310Contract.js";
+//#region src/sdk/accounts/bots/AccountBotsService.ts
+/**
+* Bots of credit accounts.
+*
+* Reads which bots are connected to an account and with which permissions,
+* and builds the transactions that connect or disconnect one.
+**/
+var AccountBotsService = class extends SDKConstruct {
+	/**
+	* Reads the bots connected to each of the given credit accounts.
+	*
+	* All reads go out as a single multicall, split into three groups: the
+	* periphery compressor's view of each account, the status of the legacy
+	* migration bot on each account, and the status of every bot in
+	* `additionalBots` on every account.
+	*
+	* @param accountsToCheck - Accounts to read, with their credit managers.
+	* @param legacyMigrationBot - Legacy migration bot to check, if any.
+	* @param additionalBots - Bots to check on every account.
+	**/
+	async getConnectedBots(accountsToCheck, legacyMigrationBot, additionalBots) {
+		const compressor = this.#compressor;
+		const compressorCalls = accountsToCheck.map(({ creditManager, creditAccount }) => {
+			const { configurator } = this.sdk.marketRegister.findByCreditManager(creditManager);
+			return compressor.connectedBotsCall(configurator.address, creditAccount);
+		});
+		const migrationCalls = legacyMigrationBot ? accountsToCheck.map((account) => this.#botStatusCall(account, legacyMigrationBot)) : [];
+		const additionalCalls = accountsToCheck.flatMap((account) => additionalBots.map((bot) => this.#botStatusCall(account, bot)));
+		const responses = await this.client.multicall({
+			contracts: [
+				...compressorCalls,
+				...migrationCalls,
+				...additionalCalls
+			],
+			allowFailure: true,
+			batchSize: 0
+		});
+		const migrationStart = compressorCalls.length;
+		const additionalStart = migrationStart + migrationCalls.length;
+		return {
+			legacy: responses.slice(0, migrationStart),
+			legacyMigration: this.#migrationBotStatuses(legacyMigrationBot, accountsToCheck.length, responses.slice(migrationStart, additionalStart)),
+			additionalBots: this.#botStatusesPerAccount(accountsToCheck.length, additionalBots.length, responses.slice(additionalStart))
+		};
+	}
+	/**
+	* Connects or disconnects a bot, and updates prices when the bot is set on a
+	* credit account.
+	*
+	* @param props - {@link SetBotProps}
+	* @returns Everything needed to execute the operation. Setting a bot on a
+	* credit manager only yields calls, since it is not a standalone transaction.
+	**/
+	async setBot({ botAddress, permissions: defaultPermissions, targetContract }) {
+		const cm = this.sdk.marketRegister.findCreditManager(targetContract.creditManager);
+		const permissions = defaultPermissions !== null ? defaultPermissions : await this.client.readContract({
+			address: botAddress,
+			abi: iBotAbi,
+			functionName: "requiredPermissions"
+		});
+		const addBotCall = cm.creditFacade.prepareSetBotPermissions(botAddress, permissions);
+		if (targetContract.type !== "creditAccount") return {
+			calls: [addBotCall],
+			creditFacade: cm.creditFacade
+		};
+		const calls = await this.sdk.accounts.prependPriceUpdates(targetContract.creditManager, [addBotCall], targetContract);
+		return {
+			tx: cm.multicallTx(targetContract.creditAccount, calls),
+			calls,
+			creditFacade: cm.creditFacade
+		};
+	}
+	/**
+	* Descriptor of a `getBotStatus` call on the bot list of an account's
+	* credit facade.
+	**/
+	#botStatusCall({ creditManager, creditAccount }, bot) {
+		const { creditFacade } = this.sdk.marketRegister.findCreditManager(creditManager);
+		return {
+			abi: iBotListV310Abi,
+			address: creditFacade.botList,
+			functionName: "getBotStatus",
+			args: [bot, creditAccount]
+		};
+	}
+	/**
+	* Regroups the flat `additionalBots` responses into one entry per account,
+	* keeping the order the bots were requested in.
+	**/
+	#botStatusesPerAccount(accounts, botsPerAccount, responses) {
+		this.#checkLength(responses, accounts * botsPerAccount, "bots");
+		const perAccount = [];
+		for (let i = 0; i < accounts; i++) perAccount.push({ result: responses.slice(i * botsPerAccount, (i + 1) * botsPerAccount) });
+		return perAccount;
+	}
+	/**
+	* Migration bot statuses, or `undefined` when no migration bot was queried.
+	**/
+	#migrationBotStatuses(bot, accounts, responses) {
+		if (!bot) return;
+		this.#checkLength(responses, accounts, "migration bots");
+		return {
+			result: responses,
+			botAddress: bot
+		};
+	}
+	#checkLength(responses, expected, what) {
+		if (responses.length !== expected) this.logger?.error(`result length mismatch for ${what}: got ${responses.length}, expected ${expected}`);
+	}
+	/**
+	* Periphery compressor of the current chain.
+	*
+	* Resolved on every access, because the address provider is only populated
+	* once the SDK is attached or hydrated; the contracts register acts as the
+	* cache.
+	**/
+	get #compressor() {
+		const [address] = this.sdk.addressProvider.mustGetLatest(AP_PERIPHERY_COMPRESSOR, VERSION_RANGE_310);
+		return this.sdk.getContract(address) ?? new PeripheryCompressorV310Contract(this.sdk, address);
+	}
+};
+//#endregion
+export { AccountBotsService };

package/dist/esm/sdk/accounts/bots/PeripheryCompressorV310Contract.js

@@ -0,0 +1,31 @@
+import { BaseContract } from "../../base/BaseContract.js";
+import "../../base/index.js";
+import { peripheryCompressorAbi } from "../../../abi/compressors/peripheryCompressor.js";
+//#region src/sdk/accounts/bots/PeripheryCompressorV310Contract.ts
+const abi = peripheryCompressorAbi;
+var PeripheryCompressorV310Contract = class extends BaseContract {
+	constructor(sdk, address) {
+		super(sdk, {
+			addr: address,
+			name: "PeripheryCompressorV310",
+			abi,
+			version: 310
+		});
+	}
+	/**
+	* Descriptor of a `getConnectedBots` call on this compressor.
+	*
+	* @param marketConfigurator - Configurator that governs the account's market.
+	* @param creditAccount - Credit account to list the connected bots of.
+	**/
+	connectedBotsCall(marketConfigurator, creditAccount) {
+		return {
+			abi,
+			address: this.address,
+			functionName: "getConnectedBots",
+			args: [marketConfigurator, creditAccount]
+		};
+	}
+};
+//#endregion
+export { PeripheryCompressorV310Contract };

package/dist/esm/sdk/accounts/bots/abi.js

@@ -0,0 +1,18 @@
+//#region src/sdk/accounts/bots/abi.ts
+/**
+* Minimal bot interface: the permissions a bot needs to operate on a credit
+* account, which the SDK reads when the caller does not specify them.
+**/
+const iBotAbi = [{
+	type: "function",
+	name: "requiredPermissions",
+	inputs: [],
+	outputs: [{
+		name: "",
+		type: "uint192",
+		internalType: "uint192"
+	}],
+	stateMutability: "view"
+}];
+//#endregion
+export { iBotAbi };

package/dist/esm/sdk/accounts/bots/index.js

@@ -0,0 +1,4 @@
+import { PeripheryCompressorV310Contract } from "./PeripheryCompressorV310Contract.js";
+import { AccountBotsService } from "./AccountBotsService.js";
+import "./types.js";
+export { AccountBotsService, PeripheryCompressorV310Contract };

package/dist/esm/sdk/accounts/bots/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/sdk/accounts/credit-account-compressor/CreditAccountCompressor.js

@@ -0,0 +1,279 @@
+import { AddressMap } from "../../utils/AddressMap.js";
+import { AddressSet } from "../../utils/AddressSet.js";
+import { AP_CREDIT_ACCOUNT_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 { iRWAFactoryAbi } from "../../../abi/rwa/iRWAFactory.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 "../../market/index.js";
+import { CreditAccountCompressorV310Contract } from "./CreditAccountCompressorV310Contract.js";
+//#region src/sdk/accounts/credit-account-compressor/CreditAccountCompressor.ts
+/**
+* Reads credit accounts of the current chain.
+*
+* Stitches the credit account compressor together with the RWA factories (for
+* accounts owned via an investor EOA) and with the withdrawal compressor (for
+* assets that are on their way out of an account), and describes the result
+* either as raw account data or as {@link StrategyPosition}s.
+*
+* TODO: create and deploy new compressor contract onchain to avoid all this stitching
+**/
+var CreditAccountCompressor = class extends SDKConstruct {
+	/**
+	* Reads data of a single credit account.
+	*
+	* When the compressor cannot value the account with current prices, the read
+	* is retried with price feed updates applied.
+	*
+	* @param account - Credit account address.
+	* @param blockNumber - Block to read at, defaults to the latest block.
+	* @returns Account data, or `undefined` if the account does not exist.
+	**/
+	async getCreditAccountData(account, blockNumber) {
+		const contract = this.#contract;
+		const raw = await contract.getCreditAccountData(account, blockNumber);
+		if (!raw) return;
+		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 marketSuite.priceOracle.priceUpdateTxsForAccount(raw);
+			[ca, investor] = await simulateWithPriceUpdates(this.client, {
+				priceUpdates: priceUpdateTxs,
+				contracts: [contract.dataCall(account), ...factory ? [{
+					abi: iRWAFactoryAbi,
+					address: factory.address,
+					functionName: "getInvestor",
+					args: [raw.creditAccount]
+				}] : []],
+				blockNumber,
+				gas: this.sdk.gasLimit
+			});
+		}
+		return {
+			...ca,
+			investor
+		};
+	}
+	/**
+	* Reads all credit accounts matching the options, sorted by health factor
+	* ascending.
+	*
+	* @param options - {@link GetCreditAccountsOptions}
+	* @param blockNumber - Block to read at, defaults to the latest block.
+	**/
+	async getCreditAccounts(options, blockNumber) {
+		const { creditManager, includeZeroDebt = false, maxHealthFactor = MAX_UINT256, minHealthFactor = 0n, owner = ADDRESS_0X0, ignoreReservePrices = false } = options ?? {};
+		const target = creditManager ?? {
+			configurators: this.#marketConfigurators,
+			creditManagers: [],
+			pools: [],
+			underlying: "0x0000000000000000000000000000000000000000"
+		};
+		const { txs: priceUpdateTxs } = await this.sdk.priceFeeds.generatePriceFeedsUpdateTxs(ignoreReservePrices ? { main: true } : void 0);
+		return (await this.#contract.getCreditAccounts(target, {
+			owner,
+			includeZeroDebt,
+			minHealthFactor,
+			maxHealthFactor
+		}, {
+			blockNumber,
+			priceUpdateTxs
+		})).sort((a, b) => Number(a.healthFactor - b.healthFactor));
+	}
+	/**
+	* Reads all credit accounts of a borrower, sorted by health factor
+	* ascending.
+	*
+	* Covers accounts the borrower owns directly and RWA accounts they own as an
+	* investor, which are owned on-chain by an RWA factory.
+	*
+	* @param borrower - Wallet address.
+	* @param options - {@link GetCreditAccountsOptions}
+	* @param blockNumber - Block to read at, defaults to the latest block.
+	**/
+	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 contract = this.#contract;
+		const rwaContracts = rwaAccountAddresses.map((account) => contract.dataCall(account));
+		const getCreditAccountsContracts = [false, true].map((reverting) => contract.accountsCall([
+			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));
+	}
+	/**
+	* Describes all credit accounts of a wallet as strategy positions.
+	*
+	* @param props - {@link ListStrategyPositionsProps}
+	**/
+	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.#toStrategyPosition(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.
+	**/
+	#toStrategyPosition(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;
+	}
+	/**
+	* Credit account compressor contract of the current chain.
+	*
+	* Resolved on every access, because the address provider is only populated
+	* once the SDK is attached or hydrated. The contracts register acts as the
+	* cache: instances register themselves there on construction, and a
+	* re-hydrated SDK with a different compressor address simply misses and
+	* builds a new wrapper.
+	**/
+	get #contract() {
+		const [address] = this.sdk.addressProvider.mustGetLatest(AP_CREDIT_ACCOUNT_COMPRESSOR, VERSION_RANGE_310);
+		return this.sdk.getContract(address) ?? new CreditAccountCompressorV310Contract(this.sdk, address);
+	}
+	/**
+	* Addresses of market configurators the SDK is attached to.
+	**/
+	get #marketConfigurators() {
+		return this.sdk.marketRegister.marketConfigurators.map((mc) => mc.address);
+	}
+};
+//#endregion
+export { CreditAccountCompressor };

package/dist/esm/sdk/accounts/credit-account-compressor/CreditAccountCompressorV310Contract.js

@@ -0,0 +1,141 @@
+import { BaseContract } from "../../base/BaseContract.js";
+import "../../base/index.js";
+import { simulateWithPriceUpdates } from "../../utils/viem/simulateWithPriceUpdates.js";
+import "../../utils/viem/index.js";
+import { creditAccountCompressorAbi } from "../../../abi/compressors/creditAccountCompressor.js";
+//#region src/sdk/accounts/credit-account-compressor/CreditAccountCompressorV310Contract.ts
+const abi = creditAccountCompressorAbi;
+/**
+* V3.10 credit account compressor.
+*
+* Wraps the compressor ABI and nothing else: single-account reads, paginated
+* multi-account reads, and call descriptors for callers that need to batch
+* these reads with calls to other contracts.
+**/
+var CreditAccountCompressorV310Contract = class extends BaseContract {
+	#sdk;
+	constructor(sdk, address) {
+		super(sdk, {
+			addr: address,
+			name: "CreditAccountCompressorV310",
+			abi,
+			version: 310
+		});
+		this.#sdk = sdk;
+	}
+	/**
+	* Reads data of a single credit account.
+	*
+	* @param account - Credit account address.
+	* @param blockNumber - Block to read at, defaults to the latest block.
+	* @returns Account data, or `undefined` if the compressor reverted, which it
+	* does when the account does not exist.
+	**/
+	async getCreditAccountData(account, blockNumber) {
+		try {
+			return await this.client.readContract({
+				abi,
+				address: this.address,
+				functionName: "getCreditAccountData",
+				args: [account],
+				blockNumber,
+				gas: this.#sdk.gasLimit
+			});
+		} catch (_e) {
+			return;
+		}
+	}
+	/**
+	* Reads all credit accounts matching the filters, in the order the
+	* compressor returns them.
+	*
+	* Two compressor quirks are handled here: results are paginated, and the
+	* `reverting` account filter is exclusive, so accounts whose collateral
+	* computation reverts are only returned by a second pass.
+	*
+	* @param target - Credit managers to query.
+	* @param query - Account-level filters, without `reverting`.
+	* @param options - Block, price updates and page size.
+	**/
+	async getCreditAccounts(target, query, options) {
+		const { batchSize, blockNumber, priceUpdateTxs } = options ?? {};
+		const allCAs = [];
+		let revertingOffset = 0;
+		for (const reverting of [false, true]) {
+			let offset = 0n;
+			revertingOffset = allCAs.length;
+			do {
+				const [accounts, newOffset] = await this.#getCreditAccounts(batchSize ? [
+					target,
+					{
+						...query,
+						reverting
+					},
+					offset,
+					batchSize
+				] : [
+					target,
+					{
+						...query,
+						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;
+	}
+	/**
+	* Descriptor of a `getCreditAccountData` call on this compressor.
+	**/
+	dataCall(account) {
+		return {
+			abi,
+			address: this.address,
+			functionName: "getCreditAccountData",
+			args: [account]
+		};
+	}
+	/**
+	* Descriptor of a `getCreditAccounts` call on this compressor.
+	**/
+	accountsCall(args) {
+		return {
+			abi,
+			address: this.address,
+			functionName: "getCreditAccounts",
+			args
+		};
+	}
+	/**
+	* One page of `getCreditAccounts`, with price updates applied when the
+	* accounts hold tokens with on-demand price feeds.
+	**/
+	async #getCreditAccounts(args, priceUpdateTxs, blockNumber) {
+		let resp;
+		if (priceUpdateTxs?.length) [resp] = await simulateWithPriceUpdates(this.client, {
+			priceUpdates: priceUpdateTxs,
+			contracts: [this.accountsCall(args)],
+			blockNumber,
+			gas: this.#sdk.gasLimit
+		});
+		else resp = await this.client.readContract({
+			abi,
+			address: this.address,
+			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;
+	}
+};
+//#endregion
+export { CreditAccountCompressorV310Contract };

package/dist/esm/sdk/accounts/credit-account-compressor/index.js

@@ -0,0 +1,4 @@
+import { CreditAccountCompressorV310Contract } from "./CreditAccountCompressorV310Contract.js";
+import { CreditAccountCompressor } from "./CreditAccountCompressor.js";
+import "./types.js";
+export { CreditAccountCompressor, CreditAccountCompressorV310Contract };

package/dist/esm/sdk/accounts/credit-account-compressor/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,3 +1,9 @@
+import { PeripheryCompressorV310Contract } from "./bots/PeripheryCompressorV310Contract.js";
+import { AccountBotsService } from "./bots/AccountBotsService.js";
+import "./bots/index.js";
+import { CreditAccountCompressorV310Contract } from "./credit-account-compressor/CreditAccountCompressorV310Contract.js";
+import { CreditAccountCompressor } from "./credit-account-compressor/CreditAccountCompressor.js";
+import "./credit-account-compressor/index.js";
 import { CreditAccountsServiceV310 } from "./CreditAccountsServiceV310.js";
 import { primaryInstantOutput } from "./intents/operations/claim-delayed/index.js";
 import { CreditAccountOperationsService } from "./intents/index.js";
@@ -18,4 +24,4 @@ import { toWithdrawalStatus } from "./withdrawal-compressor/types.js";
 import { WithdrawalCompressorV313Contract } from "./withdrawal-compressor/WithdrawalCompressorV313Contract.js";
 import { createWithdrawalCompressor } from "./withdrawal-compressor/createWithdrawalCompressor.js";
 import "./withdrawal-compressor/index.js";
-export { AbstractWithdrawalCompressorContract, CreditAccountOperationsService, CreditAccountsServiceV310, DELAYED_INTENT_TYPES, DELAYED_INTENT_VERSION, InvalidDelayedIntentError, LIQUIDATION_APPROVAL_BUFFER, LIQUIDATION_COMPRESSOR_V313_ADDRESS, LiquidationsService, MultichainLiquidationsService, RedemptionLoggerV310Contract, WithdrawalCompressorV310Contract, WithdrawalCompressorV311Contract, WithdrawalCompressorV313Contract, createRedemptionLogger, createWithdrawalCompressor, decodeDelayedIntent, encodeDelayedIntent, getWithdrawalCompressorAddress, iCreditAccountAbi, primaryInstantOutput, toClaimableWithdrawal, toPendingWithdrawal, toRequestableWithdrawal, toWithdrawalStatus };
+export { AbstractWithdrawalCompressorContract, AccountBotsService, CreditAccountCompressor, CreditAccountCompressorV310Contract, CreditAccountOperationsService, CreditAccountsServiceV310, DELAYED_INTENT_TYPES, DELAYED_INTENT_VERSION, InvalidDelayedIntentError, LIQUIDATION_APPROVAL_BUFFER, LIQUIDATION_COMPRESSOR_V313_ADDRESS, LiquidationsService, MultichainLiquidationsService, PeripheryCompressorV310Contract, RedemptionLoggerV310Contract, WithdrawalCompressorV310Contract, WithdrawalCompressorV311Contract, WithdrawalCompressorV313Contract, createRedemptionLogger, createWithdrawalCompressor, decodeDelayedIntent, encodeDelayedIntent, getWithdrawalCompressorAddress, iCreditAccountAbi, primaryInstantOutput, toClaimableWithdrawal, toPendingWithdrawal, toRequestableWithdrawal, toWithdrawalStatus };