@gearbox-protocol/sdk 15.1.0-next.1 → 15.1.0-next.10

package/dist/cjs/sdk/accounts/intents/utils/adjust-state-to-snapshot.js

@@ -0,0 +1,18 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/sdk/accounts/intents/utils/adjust-state-to-snapshot.ts
+/**
+* Maps an intents {@link OperationState} onto the {@link AccountSnapshot} that
+* position-metric functions take. `accountDebt` is treated as total debt
+* (principal plus accrued interest and fees).
+**/
+function adjustStateToSnapshot(creditManager, state) {
+	return {
+		creditManager,
+		assets: state.assets,
+		quotas: Object.values(state.quotas),
+		totalDebt: state.accountDebt,
+		totalValue: state.totalValue
+	};
+}
+//#endregion
+exports.adjustStateToSnapshot = adjustStateToSnapshot;

package/dist/cjs/sdk/accounts/intents/utils/credit-account-slice.js

@@ -0,0 +1,45 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_accounts_intents_utils_borrowed_amount_plus_interest_and_fees = require("./borrowed-amount-plus-interest-and-fees.js");
+//#region src/sdk/accounts/intents/utils/credit-account-slice.ts
+/**
+* Narrows full account data down to the slice the intent engine operates on.
+*
+* `accountDebt` is the total repayable debt (principal + accrued interest +
+* accrued fees) rather than the principal, because every debt-touching intent
+* settles the full outstanding amount.
+*
+* Addresses are lowercased so that `eq` comparisons and `AddressMap` lookups
+* behave consistently everywhere downstream.
+*/
+function toCreditAccountSlice(ca) {
+	return {
+		creditAccount: ca.creditAccount.toLowerCase(),
+		creditManager: ca.creditManager.toLowerCase(),
+		creditFacade: ca.creditFacade.toLowerCase(),
+		underlying: ca.underlying.toLowerCase(),
+		enabledTokensMask: ca.enabledTokensMask,
+		totalDebtUSD: ca.totalDebtUSD,
+		accountDebt: require_sdk_accounts_intents_utils_borrowed_amount_plus_interest_and_fees.calcBorrowedAmountPlusInterestAndFees(ca),
+		tokens: ca.tokens.map((t) => ({
+			...t,
+			token: t.token.toLowerCase()
+		}))
+	};
+}
+/**
+* Reads an account by address and narrows it to {@link CreditAccountSlice}.
+*
+* The shared read model's `StrategyPosition` carries neither `tokens` nor
+* `enabledTokensMask` / `creditFacade` / `totalDebtUSD`, so simulating against
+* an existing position costs one account read.
+*
+* @throws When the account is not found in the connected markets.
+*/
+async function fetchCreditAccountSlice(sdk, creditAccount) {
+	const data = await sdk.accounts.getCreditAccountData(creditAccount);
+	if (!data) throw new Error(`credit account not found: ${creditAccount}`);
+	return toCreditAccountSlice(data);
+}
+//#endregion
+exports.fetchCreditAccountSlice = fetchCreditAccountSlice;
+exports.toCreditAccountSlice = toCreditAccountSlice;

package/dist/cjs/sdk/accounts/intents/utils/index.js

@@ -1,19 +1,28 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sdk_accounts_intents_utils_assemble_operation_calls = require("./assemble-operation-calls.js");
-const require_sdk_accounts_intents_utils_borrowed_amount_plus_interest_and_fees = require("./borrowed-amount-plus-interest-and-fees.js");
 const require_sdk_accounts_intents_utils_common = require("./common.js");
 const require_sdk_accounts_intents_utils_convert_amount = require("./convert-amount.js");
+const require_sdk_accounts_intents_utils_pick_token = require("./pick-token.js");
+const require_sdk_accounts_intents_utils_adjust_state_to_snapshot = require("./adjust-state-to-snapshot.js");
+const require_sdk_accounts_intents_utils_assemble_operation_calls = require("./assemble-operation-calls.js");
+const require_sdk_accounts_intents_utils_borrowed_amount_plus_interest_and_fees = require("./borrowed-amount-plus-interest-and-fees.js");
+const require_sdk_accounts_intents_utils_credit_account_slice = require("./credit-account-slice.js");
+const require_sdk_accounts_intents_utils_ledger = require("./ledger.js");
 const require_sdk_accounts_intents_utils_quotas_for_update = require("./quotas-for-update.js");
-const require_sdk_accounts_intents_utils_simulate_assets = require("./simulate-assets.js");
-const require_sdk_accounts_intents_utils_simulate_adjust_state = require("./simulate-adjust-state.js");
-const require_sdk_accounts_intents_utils_with_quota_update = require("./with-quota-update.js");
+const require_sdk_accounts_intents_utils_router_path = require("./router-path.js");
+exports.OperationLedger = require_sdk_accounts_intents_utils_ledger.OperationLedger;
+exports.adjustStateToSnapshot = require_sdk_accounts_intents_utils_adjust_state_to_snapshot.adjustStateToSnapshot;
 exports.assembleOperationCalls = require_sdk_accounts_intents_utils_assemble_operation_calls.assembleOperationCalls;
 exports.calcBorrowedAmountPlusInterestAndFees = require_sdk_accounts_intents_utils_borrowed_amount_plus_interest_and_fees.calcBorrowedAmountPlusInterestAndFees;
+exports.clearedQuotas = require_sdk_accounts_intents_utils_quotas_for_update.clearedQuotas;
 exports.convertAmount = require_sdk_accounts_intents_utils_convert_amount.convertAmount;
+exports.createRouterPaths = require_sdk_accounts_intents_utils_router_path.createRouterPaths;
 exports.eq = require_sdk_accounts_intents_utils_common.eq;
-exports.getOperationsWithQuotaUpdate = require_sdk_accounts_intents_utils_with_quota_update.getOperationsWithQuotaUpdate;
+exports.fetchCreditAccountSlice = require_sdk_accounts_intents_utils_credit_account_slice.fetchCreditAccountSlice;
 exports.getQuotasForUpdate = require_sdk_accounts_intents_utils_quotas_for_update.getQuotasForUpdate;
-exports.simulateOperationAssets = require_sdk_accounts_intents_utils_simulate_assets.simulateOperationAssets;
-exports.simulateState = require_sdk_accounts_intents_utils_simulate_adjust_state.simulateState;
+exports.isPhantomToken = require_sdk_accounts_intents_utils_pick_token.isPhantomToken;
+exports.isRedemptionPhantomToken = require_sdk_accounts_intents_utils_pick_token.isRedemptionPhantomToken;
+exports.pickFattestNonPhantomToken = require_sdk_accounts_intents_utils_pick_token.pickFattestNonPhantomToken;
+exports.rankAccountTokens = require_sdk_accounts_intents_utils_pick_token.rankAccountTokens;
+exports.toCreditAccountSlice = require_sdk_accounts_intents_utils_credit_account_slice.toCreditAccountSlice;
 exports.toRouterCaSlice = require_sdk_accounts_intents_utils_common.toRouterCaSlice;
 exports.toTargetDecimals = require_sdk_accounts_intents_utils_common.toTargetDecimals;

package/dist/cjs/sdk/accounts/intents/utils/ledger.js

@@ -0,0 +1,94 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_utils_bigint_math = require("../../../utils/bigint-math.js");
+//#region src/sdk/accounts/intents/utils/ledger.ts
+/**
+* Running account state, advanced one operation at a time.
+*
+* Exists because the amounts an operation is built from depend on the balances
+* the previous ones left behind: a swap has to know how much of its input token
+* is genuinely swap input, so the router does not sweep collateral that must
+* stay put. Applying each op as it is built keeps that a single forward pass —
+* a builder that re-simulated the chain from the start for every leg would be
+* quadratic in the number of legs and easy to desynchronise.
+*/
+var OperationLedger = class {
+	#balances = /* @__PURE__ */ new Map();
+	#underlying;
+	#convert;
+	#debt;
+	constructor(args) {
+		this.#underlying = args.underlying;
+		this.#convert = args.convert;
+		this.#debt = args.debt;
+		for (const asset of args.initialAssets) {
+			const token = asset.token.toLowerCase();
+			this.#balances.set(token, (this.#balances.get(token) ?? 0n) + asset.balance);
+		}
+	}
+	get debt() {
+		return this.#debt;
+	}
+	balanceOf(token) {
+		return this.#balances.get(token.toLowerCase()) ?? 0n;
+	}
+	applyAll(operations) {
+		for (const op of operations) this.apply(op);
+		return this;
+	}
+	snapshot() {
+		const assets = [...this.#balances.entries()].map(([token, balance]) => ({
+			token,
+			balance
+		}));
+		return {
+			assets,
+			totalValue: assets.reduce((acc, a) => acc + this.#convert(a.token, this.#underlying, a.balance), 0n),
+			debt: this.#debt
+		};
+	}
+	/** Advances the state by one operation; quota changes move no balance. */
+	apply(op) {
+		switch (op.type) {
+			case "changeQuota": break;
+			case "increaseDebt":
+				this.#debt += op.amount;
+				this.#add(this.#underlying, op.amount);
+				break;
+			case "decreaseDebt":
+				this.#debt = require_sdk_utils_bigint_math.BigIntMath.max(0n, this.#debt - op.amount);
+				this.#add(this.#underlying, -op.amount);
+				break;
+			case "addCollateral":
+				this.#add(op.token, op.amount);
+				break;
+			case "withdrawCollateral":
+				this.#add(op.token, -op.amount);
+				break;
+			case "swap":
+				for (const input of op.from) this.#add(input.token, -input.balance);
+				this.#add(op.tokenOut, op.amountOut);
+				break;
+			case "wrapRwaCollateral":
+			case "unwrapRwaCollateral":
+				this.#add(op.tokenIn, -op.amount);
+				this.#add(op.tokenOut, op.amountOut);
+				break;
+			case "startDelayedWithdrawal":
+				this.#add(op.token, -op.amountIn);
+				for (const out of op.outputs) this.#add(out.token, out.amount);
+				break;
+			case "claimDelayedWithdrawal":
+				this.#add(op.withdrawalPhantomToken, -op.withdrawalTokenSpent);
+				for (const out of op.outputs) this.#add(out.token, out.amount);
+		}
+		return this;
+	}
+	#add(token, delta) {
+		const key = token.toLowerCase();
+		const balance = (this.#balances.get(key) ?? 0n) + delta;
+		if (balance <= 0n) this.#balances.delete(key);
+		else this.#balances.set(key, balance);
+	}
+};
+//#endregion
+exports.OperationLedger = OperationLedger;

package/dist/cjs/sdk/accounts/intents/utils/pick-token.js

@@ -0,0 +1,72 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_market_credit_isStrategyCollateral = require("../../../market/credit/isStrategyCollateral.js");
+const require_sdk_accounts_intents_utils_common = require("./common.js");
+const require_sdk_accounts_intents_utils_convert_amount = require("./convert-amount.js");
+//#region src/sdk/accounts/intents/utils/pick-token.ts
+/** Prefix marking every phantom-token contract type in the registry. */
+const PHANTOM_TOKEN_PREFIX = "PHANTOM_TOKEN::";
+/**
+* Whether `token` is a phantom (a non-transferable position marker such as a
+* pending delayed withdrawal).
+*
+* Reads `contractType` directly instead of going through
+* `TokensMeta.isPhantomToken`, which throws when extended token data has not
+* been loaded. Here an unknown token is simply treated as non-phantom.
+*/
+function isPhantomToken(sdk, token) {
+	return !!sdk.tokensMeta.get(token)?.contractType?.startsWith(PHANTOM_TOKEN_PREFIX);
+}
+const REDEMPTION_PHANTOM_TOKEN_TYPES = new Set(require_sdk_market_credit_isStrategyCollateral.NON_STRATEGY_PHANTOM_TOKEN_TYPES);
+/**
+* Whether `token` is the phantom of a redemption in flight, rather than one of
+* the phantoms a position is simply held in (Convex, Infrared, staking
+* rewards), which the router sells like any other balance.
+*
+* Only the former stands between an account and being emptied: it cannot be
+* sold and it cannot leave until its claim has landed.
+*/
+function isRedemptionPhantomToken(sdk, token) {
+	const contractType = sdk.tokensMeta.get(token)?.contractType;
+	return !!contractType && REDEMPTION_PHANTOM_TOKEN_TYPES.has(contractType);
+}
+/**
+* Account balances that can actually back an operation, richest first.
+*
+* Phantoms are dropped because a pending delayed withdrawal cannot be spent:
+* it has to be claimed first, in a transaction of its own.
+*/
+function rankAccountTokens(args) {
+	const { creditAccount, sdk, exclude = [] } = args;
+	const convert = require_sdk_accounts_intents_utils_convert_amount.convertAmount(sdk, creditAccount.creditManager);
+	const candidates = [];
+	for (const t of creditAccount.tokens) {
+		if (t.balance <= 0n) continue;
+		if (exclude.some((e) => require_sdk_accounts_intents_utils_common.eq(e, t.token))) continue;
+		if (isPhantomToken(sdk, t.token)) continue;
+		candidates.push({
+			token: t.token,
+			balance: t.balance,
+			valueInUnderlying: convert(t.token, creditAccount.underlying, t.balance)
+		});
+	}
+	candidates.sort((a, b) => {
+		if (a.valueInUnderlying !== b.valueInUnderlying) return a.valueInUnderlying > b.valueInUnderlying ? -1 : 1;
+		return a.token < b.token ? -1 : a.token > b.token ? 1 : 0;
+	});
+	return candidates;
+}
+/**
+* Default working token for flows that do not get one from the caller: the
+* most valuable non-phantom balance on the account.
+*
+* Used for the source of a partial withdraw and the position leg of a leverage
+* adjustment, both of which the caller may override explicitly.
+*/
+function pickFattestNonPhantomToken(args) {
+	return rankAccountTokens(args)[0];
+}
+//#endregion
+exports.isPhantomToken = isPhantomToken;
+exports.isRedemptionPhantomToken = isRedemptionPhantomToken;
+exports.pickFattestNonPhantomToken = pickFattestNonPhantomToken;
+exports.rankAccountTokens = rankAccountTokens;

package/dist/cjs/sdk/accounts/intents/utils/quotas-for-update.js

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_sdk_utils_mappers = require("../../../utils/mappers.js");
+const require_sdk_constants_math = require("../../../constants/math.js");
 const require_common_utils_utils_creditAccount_quota_utils = require("../../../../common-utils/utils/creditAccount/quota-utils.js");
 //#region src/sdk/accounts/intents/utils/quotas-for-update.ts
 function getQuotasForUpdate({ assetsBefore, assetsAfter, initialQuotas, quotaReserve = 0, liquidationThresholds: liquidationThresholdsMap, quotas: quotasMap, maxDebt, underlyingToken, convert }) {
@@ -52,6 +53,31 @@ function getQuotasForUpdate({ assetsBefore, assetsAfter, initialQuotas, quotaRes
 	});
 	return filterQuotaUpdates(quotaResult.desiredQuota, quotaResult.quotaIncrease, quotaResult.quotaDecrease, [...new Set([...spend, ...obtain].map((q) => q.token)).values()]);
 }
+/**
+* The update that leaves the account holding no quota at all.
+*
+* Sits beside {@link getQuotasForUpdate} rather than inside it because the two
+* answer different questions: that one sizes quotas to the balances an
+* operation leaves behind, this one is asked for by a plan that ends the loan,
+* where the right size is none whatever the balances are.
+*
+* `MIN_INT96` is the protocol's "reset" sentinel, which is how a decrease says
+* "all of it" instead of naming an amount that interest may have moved.
+*/
+function clearedQuotas(initialQuotas) {
+	const quoted = initialQuotas.filter((q) => q.quota > 0n).map((q) => q.token.toLowerCase());
+	return {
+		desiredQuota: require_sdk_utils_mappers.TypedObjectUtils.fromEntries(quoted.map((token) => [token, {
+			token,
+			balance: 0n
+		}])),
+		quotaIncrease: [],
+		quotaDecrease: quoted.map((token) => ({
+			token,
+			balance: require_sdk_constants_math.MIN_INT96
+		}))
+	};
+}
 function collectQuotaChange(assetsBefore, assetsAfter) {
 	const before = new Map(assetsBefore.map((a) => [a.token, a.balance]));
 	const after = new Map(assetsAfter.map((a) => [a.token, a.balance]));
@@ -119,4 +145,5 @@ function constructAssetRecord(a) {
 	}, {});
 }
 //#endregion
+exports.clearedQuotas = clearedQuotas;
 exports.getQuotasForUpdate = getQuotasForUpdate;

package/dist/cjs/sdk/accounts/intents/utils/router-path.js

@@ -0,0 +1,86 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_accounts_intents_utils_common = require("./common.js");
+//#region src/sdk/accounts/intents/utils/router-path.ts
+/**
+* The engine's only door to the pathfinder.
+*
+* Deliberately not a quoter abstraction with an oracle-priced twin: paths are
+* always resolved on-chain, because a preview whose swap amounts came from
+* oracle prices could not produce the calldata that realises them.
+*/
+function createRouterPaths(args) {
+	const { sdk, creditAccount, slippage } = args;
+	const suite = sdk.marketRegister.findCreditManager(creditAccount.creditManager);
+	const cmSlice = {
+		address: suite.creditManager.address.toLowerCase(),
+		creditFacade: suite.creditFacade.address.toLowerCase(),
+		collateralTokens: suite.creditManager.collateralTokens.map((t) => t.toLowerCase())
+	};
+	const router = sdk.routerFor({ creditFacade: suite.creditFacade.address });
+	return {
+		async swap({ tokenIn, tokenOut, amount, keep = 0n }) {
+			if (amount <= 0n) return {
+				amount: 0n,
+				minAmount: 0n,
+				calls: []
+			};
+			if (keep < 0n) throw new Error(`swap: spending ${amount} of ${tokenIn} exceeds its balance`);
+			if (keep > 0n) {
+				const expectedBalances = [{
+					token: tokenIn,
+					balance: amount + keep
+				}];
+				return router.findManyToOnePath({
+					creditAccount: require_sdk_accounts_intents_utils_common.toRouterCaSlice(creditAccount, expectedBalances),
+					creditManager: cmSlice,
+					expectedBalances,
+					leftoverBalances: [{
+						token: tokenIn,
+						balance: keep
+					}],
+					target: tokenOut,
+					slippage
+				});
+			}
+			return router.findOneTokenPath({
+				creditAccount: require_sdk_accounts_intents_utils_common.toRouterCaSlice(creditAccount, [{
+					token: tokenIn,
+					balance: amount
+				}]),
+				creditManager: cmSlice,
+				tokenIn,
+				tokenOut,
+				amount,
+				slippage
+			});
+		},
+		async closeAll({ balances }) {
+			const { amount, minAmount, calls } = await router.findBestClosePath({
+				creditAccount: require_sdk_accounts_intents_utils_common.toRouterCaSlice(creditAccount, balances),
+				creditManager: cmSlice,
+				balances: {
+					expectedBalances: balances,
+					leftoverBalances: [],
+					tokensToClaim: []
+				},
+				slippage
+			});
+			return {
+				amount,
+				minAmount,
+				calls: [...calls]
+			};
+		},
+		async openStrategy({ expectedBalances, leftoverBalances, target }) {
+			return router.findOpenStrategyPath({
+				creditManager: cmSlice,
+				expectedBalances,
+				leftoverBalances,
+				target,
+				slippage
+			});
+		}
+	};
+}
+//#endregion
+exports.createRouterPaths = createRouterPaths;

package/dist/cjs/sdk/accounts/intents/view.js

@@ -0,0 +1,38 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_accounts_intents_utils_common = require("./utils/common.js");
+const require_sdk_accounts_intents_utils_convert_amount = require("./utils/convert-amount.js");
+const require_sdk_accounts_intents_utils_pick_token = require("./utils/pick-token.js");
+//#region src/sdk/accounts/intents/view.ts
+/**
+* The account as the planners see it: a handful of numbers in underlying units
+* plus balance / price lookups. Read once per preview.
+*
+* TVL uses the RWA-aware conversion so an `rwa.asset` balance without a direct
+* pool price still counts at its wrapped value instead of throwing.
+*/
+function accountView(creditAccount, sdk) {
+	const { underlying, creditManager } = creditAccount;
+	const price = require_sdk_accounts_intents_utils_convert_amount.convertAmount(sdk, creditManager);
+	const { creditFacade } = sdk.marketRegister.findCreditManager(creditManager);
+	let totalValue = 0n;
+	for (const t of creditAccount.tokens) totalValue += price(t.token, underlying, t.balance);
+	return {
+		underlying,
+		rwaAsset: sdk.tokensMeta.rwaUnderlyings.get(underlying)?.asset,
+		debt: creditAccount.accountDebt,
+		collateral: totalValue - creditAccount.accountDebt,
+		band: {
+			minDebt: creditFacade.minDebt,
+			maxDebt: creditFacade.maxDebt
+		},
+		balanceOf: (token) => creditAccount.tokens.find((t) => require_sdk_accounts_intents_utils_common.eq(t.token, token))?.balance ?? 0n,
+		price,
+		fattest: (exclude) => require_sdk_accounts_intents_utils_pick_token.pickFattestNonPhantomToken({
+			creditAccount,
+			sdk,
+			exclude
+		})?.token
+	};
+}
+//#endregion
+exports.accountView = accountView;

package/dist/cjs/sdk/accounts/liquidations/LiquidationsService.js

@@ -33,7 +33,6 @@ var LiquidationsService = class extends require_sdk_base_SDKConstruct.SDKConstru
 	* Accounts whose collateral computation failed are excluded.
 	**/
 	async getLiquidatableAccounts(props) {
-		await this.sdk.withdrawalCompressor?.loadWithdrawableAssets(void 0, props?.blockNumber);
 		const unhealthy = await this.sdk.accounts.getCreditAccounts({
 			maxHealthFactor: require_sdk_constants_math.WAD - 1n,
 			includeZeroDebt: false
@@ -60,7 +59,6 @@ var LiquidationsService = class extends require_sdk_base_SDKConstruct.SDKConstru
 		const ca = await this.#getCreditAccountData(creditAccount, blockNumber);
 		const suite = this.sdk.marketRegister.findCreditManager(ca.creditManager);
 		const { priceOracle } = suite.market;
-		await this.sdk.withdrawalCompressor?.loadWithdrawableAssets(void 0, blockNumber);
 		const account = this.#buildAccount(ca, suite);
 		const data = await this.#getLiquidationData(ca, liquidator, ignoreReservePrices, blockNumber);
 		return {
@@ -97,7 +95,6 @@ var LiquidationsService = class extends require_sdk_base_SDKConstruct.SDKConstru
 	async getLiquidationPositions(props) {
 		const compressor = this.sdk.withdrawalCompressor;
 		if (!compressor) return [];
-		await compressor.loadWithdrawableAssets(void 0, props.blockNumber);
 		const phantomTokens = new require_sdk_utils_AddressSet.AddressSet(compressor.getWithdrawableAssets().map((a) => a.withdrawalPhantomToken));
 		const { claimable, pending } = await compressor.getExternalAccountCurrentWithdrawals({
 			account: props.liquidator,

package/dist/cjs/sdk/accounts/withdrawal-compressor/AbstractWithdrawalCompressorContract.js

@@ -4,8 +4,10 @@ require("../../constants/addresses.js");
 require("../../constants/index.js");
 const require_sdk_utils_hex = require("../../utils/hex.js");
 require("../../utils/index.js");
+const require_sdk_utils_viem_executeMulticallBatches = require("../../utils/viem/executeMulticallBatches.js");
 const require_sdk_base_BaseContract = require("../../base/BaseContract.js");
 require("../../base/index.js");
+require("../../utils/viem/index.js");
 const require_sdk_accounts_withdrawal_compressor_intent_codec = require("./intent-codec.js");
 let viem = require("viem");
 //#region src/sdk/accounts/withdrawal-compressor/AbstractWithdrawalCompressorContract.ts
@@ -58,37 +60,46 @@ var AbstractWithdrawalCompressorContract = class extends require_sdk_base_BaseCo
 	**/
 	getWithdrawableAssets(...creditManagers) {
 		const cache = this.#withdrawableAssets;
-		if (!cache) throw new Error("withdrawable assets are not loaded, call loadWithdrawableAssets first");
+		if (!cache) throw new Error("withdrawable assets are not loaded, check if the sdk was properly attached or hydrated");
 		if (creditManagers.length === 0) return cache.values().flat();
 		return creditManagers.flatMap((cm) => cache.get(cm) ?? []);
 	}
 	/**
-	* {@inheritDoc IWithdrawalCompressorContract.loadWithdrawableAssets}
+	* {@inheritDoc IWithdrawalCompressorContract.getLoadWithdrawableAssetsMulticall}
 	**/
-	async loadWithdrawableAssets(force, blockNumber) {
-		if (this.#withdrawableAssets && !force) return this.getWithdrawableAssets();
+	getLoadWithdrawableAssetsMulticall(force) {
+		if (this.#withdrawableAssets && !force) return {
+			contracts: [],
+			onResults: () => {}
+		};
 		const cms = this.#sdk.marketRegister.creditManagers.map((cm) => cm.creditManager.address);
-		const resp = await this.client.multicall({
+		return {
 			contracts: cms.map((cm) => ({
 				address: this.address,
 				abi: this.abi,
 				functionName: "getWithdrawableAssets",
 				args: [cm]
 			})),
-			allowFailure: true,
-			batchSize: 0,
-			blockNumber
-		});
-		const cache = new require_sdk_utils_AddressMap.AddressMap(void 0, MAP_LABEL);
-		for (let i = 0; i < resp.length; i++) {
-			const r = resp[i];
-			if (r.status !== "success") {
-				this.logger?.warn(`failed to get withdrawable assets of credit manager ${cms[i]}: ${r.error}`);
-				continue;
+			onResults: (resps) => {
+				const cache = new require_sdk_utils_AddressMap.AddressMap(void 0, MAP_LABEL);
+				for (let i = 0; i < resps.length; i++) {
+					const r = resps[i];
+					if (r.status !== "success") {
+						this.logger?.warn(`failed to get withdrawable assets of credit manager ${cms[i]}: ${r.error}`);
+						continue;
+					}
+					const assets = r.result;
+					if (assets.length > 0) cache.upsert(cms[i], assets.map((a) => toWithdrawableAsset(a, cms[i])));
+				}
+				this.#withdrawableAssets = cache;
 			}
-			if (r.result.length > 0) cache.upsert(cms[i], r.result.map((a) => toWithdrawableAsset(a, cms[i])));
-		}
-		this.#withdrawableAssets = cache;
+		};
+	}
+	/**
+	* {@inheritDoc IWithdrawalCompressorContract.loadWithdrawableAssets}
+	**/
+	async loadWithdrawableAssets(force, blockNumber) {
+		await require_sdk_utils_viem_executeMulticallBatches.executeMulticallBatches(this.client, [this.getLoadWithdrawableAssetsMulticall(force)], { blockNumber });
 		return this.getWithdrawableAssets();
 	}
 	/**

package/dist/cjs/sdk/base/BaseContract.js

@@ -171,7 +171,7 @@ var BaseContract = class extends require_sdk_base_Construct.Construct {
 			name: decoded.functionName,
 			args: decoded.args
 		});
-		if (!abiItem || abiItem.type !== "function") return `Unknown function: ${decoded.functionName}`;
+		if (abiItem?.type !== "function") return `Unknown function: ${decoded.functionName}`;
 		const params = this.stringifyFunctionParams(decoded).map((v, i) => `${abiItem.inputs[i].name}: ${v}`);
 		return `${this.name}.${decoded.functionName}({${params.join(", ")}})`;
 	}