@gearbox-protocol/sdk 15.1.0-next.9 → 16.0.0-next.2

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

@@ -0,0 +1,312 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_market_math = require("../../market/math.js");
+const require_sdk_accounts_intents_types = require("./types.js");
+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");
+const require_sdk_accounts_intents_guards = require("./guards.js");
+const require_sdk_accounts_intents_utils_ledger = require("./utils/ledger.js");
+const require_sdk_accounts_intents_utils_quotas_for_update = require("./utils/quotas-for-update.js");
+const require_sdk_accounts_intents_utils_router_path = require("./utils/router-path.js");
+const require_sdk_accounts_intents_operations = require("./operations.js");
+//#region src/sdk/accounts/intents/realize.ts
+/**
+* Turns a plan into operations: the one place that talks to the router, knows
+* how an RWA leg differs from a swap, and keeps the running balances.
+*
+* Steps are applied to a ledger as they are built, so every leg sees the
+* balances the previous ones left behind: a swap only spends what the plan
+* says and keeps the rest of its input token in place, a repayment never
+* exceeds the underlying actually raised. Once the walk is done the projected
+* balances yield the quota update and the reported state.
+*/
+async function realize(steps, props) {
+	const { creditAccount, sdk, slippage, quotaReserve } = props;
+	const { underlying } = creditAccount;
+	const rwaAsset = sdk.tokensMeta.rwaUnderlyings.get(underlying)?.asset;
+	const price = require_sdk_accounts_intents_utils_convert_amount.convertAmount(sdk, creditAccount.creditManager);
+	const paths = props.paths ?? require_sdk_accounts_intents_utils_router_path.createRouterPaths({
+		sdk,
+		creditAccount,
+		slippage
+	});
+	const market = sdk.marketRegister.findByCreditManager(creditAccount.creditManager);
+	const suite = sdk.marketRegister.findCreditManager(creditAccount.creditManager);
+	const ledger = new require_sdk_accounts_intents_utils_ledger.OperationLedger({
+		initialAssets: creditAccount.tokens,
+		underlying,
+		debt: creditAccount.accountDebt,
+		convert: price
+	});
+	const operations = [];
+	const push = (op) => {
+		operations.push(op);
+		ledger.apply(op);
+	};
+	/** Output of the last convert or claim, for `RAISED` amounts. */
+	let raised = 0n;
+	/** The request, before the walk's end state can be attached to it. */
+	let delayed;
+	/**
+	* Set by a `clearQuotas` step, which settles the quotas mid-walk instead of
+	* at the end — and settles them at none, whatever the balances turn out to be.
+	*/
+	let cleared;
+	/**
+	* Whether anything leaves the account, which is what makes the credit manager
+	* judge the closing collateral check at safe prices.
+	*/
+	let paysOut = false;
+	const amountOf = (a) => typeof a === "bigint" ? a : min(raised, a.max ?? raised);
+	const assertHolds = (token, amount, what) => {
+		const held = ledger.balanceOf(token);
+		if (amount <= 0n || held < amount) throw new require_sdk_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", `${what}: needs ${amount} of ${token}, account holds ${held}`);
+	};
+	for (const step of steps) switch (step.kind) {
+		case "add":
+			push(require_sdk_accounts_intents_operations.buildAddCollateralOperation({
+				token: step.token,
+				amount: step.amount,
+				value: step.value,
+				creditAccount,
+				sdk
+			}));
+			break;
+		case "borrow":
+			require_sdk_accounts_intents_guards.assertCanBorrow(suite, step.amount);
+			push(require_sdk_accounts_intents_operations.buildIncreaseDebtOperation({
+				amount: step.amount,
+				creditAccount,
+				sdk
+			}));
+			break;
+		case "repay": {
+			const amount = min(amountOf(step.amount), ledger.balanceOf(underlying) - (step.keep ?? 0n));
+			if (amount > 0n) push(require_sdk_accounts_intents_operations.buildDecreaseDebtOperation({
+				amount,
+				full: amount >= ledger.debt,
+				creditAccount,
+				sdk
+			}));
+			break;
+		}
+		case "clearQuotas":
+			cleared = require_sdk_accounts_intents_utils_quotas_for_update.clearedQuotas(creditAccount.tokens);
+			if (cleared.quotaDecrease.length > 0) push(require_sdk_accounts_intents_operations.buildQuotaUpdateOperation({
+				update: cleared,
+				creditAccount,
+				sdk
+			}));
+			break;
+		case "convert": {
+			const amount = amountOf(step.amount);
+			if (amount <= 0n) {
+				raised = 0n;
+				break;
+			}
+			assertHolds(step.from, amount, "convert");
+			if (require_sdk_accounts_intents_utils_common.eq(step.from, step.to)) {
+				raised = amount;
+				break;
+			}
+			const wrap = rwaAsset && require_sdk_accounts_intents_utils_common.eq(step.from, rwaAsset) && require_sdk_accounts_intents_utils_common.eq(step.to, underlying);
+			const unwrap = rwaAsset && require_sdk_accounts_intents_utils_common.eq(step.from, underlying) && require_sdk_accounts_intents_utils_common.eq(step.to, rwaAsset);
+			if (wrap || unwrap) {
+				const amountOut = require_sdk_accounts_intents_utils_common.toTargetDecimals(amount, step.from, step.to, sdk);
+				push(await (wrap ? require_sdk_accounts_intents_operations.buildWrapRwaCollateralOperation : require_sdk_accounts_intents_operations.buildUnwrapRwaCollateralOperation)({
+					tokenIn: step.from,
+					amountIn: amount,
+					tokenOut: step.to,
+					amountOut,
+					creditAccount,
+					sdk
+				}));
+				raised = amountOut;
+				break;
+			}
+			const held = ledger.balanceOf(step.from);
+			const leg = await paths.swap({
+				tokenIn: step.from,
+				tokenOut: step.to,
+				amount,
+				keep: held - amount
+			});
+			push(require_sdk_accounts_intents_operations.buildSwapOperation({
+				tokenIn: step.from,
+				amountIn: amount,
+				tokenOut: step.to,
+				amountOut: leg.minAmount,
+				calls: leg.calls
+			}));
+			raised = leg.minAmount;
+			break;
+		}
+		case "closeAll": {
+			const balances = ledger.snapshot().assets.filter((a) => !require_sdk_accounts_intents_utils_common.eq(a.token, underlying) && a.balance > DUST);
+			const pending = balances.find((a) => require_sdk_accounts_intents_utils_pick_token.isRedemptionPhantomToken(sdk, a.token));
+			if (pending) throw new require_sdk_accounts_intents_types.IntentPreviewError("withdrawalInProgress", `closeAll: ${pending.token} is a pending withdrawal, claim it first`);
+			if (balances.length > 0) {
+				const leg = await paths.closeAll({ balances });
+				if (leg.calls.length > 0 || leg.minAmount > 0n) push(require_sdk_accounts_intents_operations.buildCloseSwapOperation({
+					from: balances,
+					tokenOut: underlying,
+					amountOut: leg.minAmount,
+					calls: leg.calls
+				}));
+			}
+			raised = ledger.balanceOf(underlying);
+			break;
+		}
+		case "withdraw": {
+			const amount = amountOf(step.amount);
+			assertHolds(step.token, amount, "withdraw");
+			paysOut = true;
+			push(require_sdk_accounts_intents_operations.buildWithdrawCollateralOperation({
+				token: step.token,
+				amount,
+				to: step.to,
+				creditAccount,
+				sdk
+			}));
+			break;
+		}
+		case "request": {
+			const asset = await delayedConfig(sdk, creditAccount, step.token);
+			if (ledger.balanceOf(asset.withdrawalPhantomToken) > 0n) throw new require_sdk_accounts_intents_types.IntentPreviewError("withdrawalInProgress", `request: ${asset.withdrawalPhantomToken} already holds a pending withdrawal`);
+			assertHolds(step.token, step.amount + step.reserve, "request");
+			const preview = await sdk.accounts.previewDelayedWithdrawal({
+				creditAccount: creditAccount.creditAccount,
+				token: step.token,
+				amount: step.amount,
+				withdrawalPhantomToken: asset.withdrawalPhantomToken,
+				intent: step.record
+			});
+			push(require_sdk_accounts_intents_operations.buildStartDelayedWithdrawalOperation({
+				preview,
+				creditAccount,
+				sdk
+			}));
+			const queued = preview.outputs.find((o) => o.isDelayed);
+			delayed = {
+				record: step.record,
+				claimableAt: preview.claimableAt,
+				settlement: queued ? "delayed" : "instant",
+				claim: queued ? {
+					token: asset.underlying.toLowerCase(),
+					amount: require_sdk_accounts_intents_utils_common.toTargetDecimals(queued.amount, queued.token, asset.underlying, sdk)
+				} : void 0
+			};
+			raised = require_sdk_accounts_intents_operations.instantOutput(preview.outputs)?.amount ?? 0n;
+			break;
+		}
+		case "claim":
+			push(require_sdk_accounts_intents_operations.buildClaimDelayedWithdrawalOperation({
+				claimable: step.claimable,
+				creditAccount,
+				sdk
+			}));
+			raised = require_sdk_accounts_intents_operations.instantOutput(step.claimable.outputs)?.amount ?? 0n;
+			break;
+		case "sweep": {
+			paysOut = true;
+			const wrapped = ledger.balanceOf(underlying);
+			if (rwaAsset && wrapped > 0n) push(await require_sdk_accounts_intents_operations.buildUnwrapRwaCollateralOperation({
+				tokenIn: underlying,
+				amountIn: wrapped,
+				tokenOut: rwaAsset,
+				amountOut: require_sdk_accounts_intents_utils_common.toTargetDecimals(wrapped, underlying, rwaAsset, sdk),
+				creditAccount,
+				sdk
+			}));
+			for (const { token, balance } of ledger.snapshot().assets) push(require_sdk_accounts_intents_operations.buildWithdrawCollateralOperation({
+				token,
+				amount: balance,
+				to: step.to,
+				all: true,
+				creditAccount,
+				sdk
+			}));
+			break;
+		}
+	}
+	const { assets, totalValue, debt } = ledger.snapshot();
+	require_sdk_accounts_intents_guards.assertGrowthAllowed({
+		sdk,
+		suite,
+		market,
+		before: creditAccount.tokens,
+		after: assets
+	});
+	const quotas = cleared ?? require_sdk_accounts_intents_utils_quotas_for_update.getQuotasForUpdate({
+		assetsBefore: creditAccount.tokens,
+		assetsAfter: assets,
+		initialQuotas: creditAccount.tokens,
+		quotaReserve,
+		underlyingToken: underlying,
+		liquidationThresholds: suite.creditManager.liquidationThresholds,
+		quotas: market.pool.pqk.quotas,
+		maxDebt: suite.creditFacade.maxDebt,
+		convert: price
+	});
+	if (!cleared && quotas.quotaIncrease.length + quotas.quotaDecrease.length > 0) {
+		require_sdk_accounts_intents_guards.assertQuotaHeadroom(market, quotas.quotaIncrease);
+		push(require_sdk_accounts_intents_operations.buildQuotaUpdateOperation({
+			update: quotas,
+			creditAccount,
+			sdk
+		}));
+	}
+	const quotasAfter = require_sdk_accounts_intents_utils_quotas_for_update.quotasAfterUpdate(creditAccount.tokens, quotas.desiredQuota);
+	const snapshot = {
+		creditManager: creditAccount.creditManager,
+		assets,
+		quotas: Object.values(quotasAfter),
+		totalDebt: debt,
+		totalValue
+	};
+	const projectedPool = { availableLiquidityChange: creditAccount.accountDebt - debt };
+	const metrics = {
+		healthFactor: sdk.positions.healthFactor(snapshot),
+		borrowRate: sdk.positions.borrowRate(snapshot, projectedPool),
+		timeToLiquidation: sdk.positions.timeToLiquidation(snapshot, projectedPool),
+		liquidationPrice: sdk.positions.liquidationPrice(snapshot)
+	};
+	require_sdk_accounts_intents_guards.assertCollateralised(paysOut ? sdk.positions.healthFactor(snapshot, { safePrices: true }) : metrics.healthFactor);
+	const state = {
+		totalValue,
+		accountDebt: debt,
+		leverage: require_sdk_market_math.calcPositionLeverage(totalValue, debt),
+		assets: assets.map((a) => market.priceOracle.toTokenAmount(a.token, a.balance)),
+		quotas: quotasAfter,
+		...metrics
+	};
+	return {
+		operations,
+		state,
+		calls: callsOf(operations),
+		delayed: delayed && {
+			...delayed,
+			afterRequest: state
+		}
+	};
+}
+/**
+* The redemption config for `token`, when the credit manager offers exactly one.
+*
+* Several configs mean several venues with different delays and outputs, and
+* nothing in the intent says which one was meant.
+*/
+async function delayedConfig(sdk, creditAccount, token) {
+	const compressor = sdk.withdrawalCompressor;
+	if (!compressor) throw new require_sdk_accounts_intents_types.IntentPreviewError("noDelayedRoute", "request: chain has no withdrawal compressor");
+	const assets = await compressor.findWithdrawableAssets(creditAccount.creditManager, token);
+	if (assets.length === 0) throw new require_sdk_accounts_intents_types.IntentPreviewError("noDelayedRoute", `request: ${token} has no delayed withdrawal config`);
+	if (assets.length > 1) throw new require_sdk_accounts_intents_types.IntentPreviewError("multipleDelayedWithdrawals", `request: ${token} has ${assets.length} delayed withdrawal configs`);
+	return assets[0];
+}
+const callsOf = (operations) => operations.flatMap((op) => op.calls);
+const min = (a, b) => a < b ? a : b;
+/** Balance the router's close path refuses to route, and leaves in place. */
+const DUST = 10n;
+//#endregion
+exports.realize = realize;

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

@@ -0,0 +1,123 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_accounts_intents_types = require("./types.js");
+const require_sdk_accounts_intents_utils_router_path = require("./utils/router-path.js");
+const require_sdk_accounts_intents_plan = require("./plan.js");
+const require_sdk_accounts_intents_operations = require("./operations.js");
+const require_sdk_accounts_intents_realize = require("./realize.js");
+const require_sdk_accounts_intents_view = require("./view.js");
+//#region src/sdk/accounts/intents/tail.ts
+/**
+* The second half of a delayed intent: the claim, then whatever the intent
+* still owes.
+*
+* Shared by the two callers that need it and must not disagree — the tail as
+* it is previewed days later against the account that really exists, and the
+* tail as it is projected the moment the request is made.
+*/
+function planTail(args) {
+	const { intent, claimable, view } = args;
+	const claimed = () => {
+		const output = require_sdk_accounts_intents_operations.instantOutput(claimable.outputs);
+		if (!output) throw new require_sdk_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", "finishIntent: the claim credits nothing to spend");
+		return output;
+	};
+	switch (intent.type) {
+		case "WITHDRAW_COLLATERAL": return require_sdk_accounts_intents_plan.planFinishWithdraw(intent, claimable, claimed(), view);
+		case "DECREASE_LEVERAGE": return require_sdk_accounts_intents_plan.planFinishDecreaseLeverage(claimable, claimed(), view);
+		case "CLOSE_ACCOUNT": return require_sdk_accounts_intents_plan.planFinishCloseAccount(intent, claimable, claimed(), view);
+		case "ADD_COLLATERAL":
+		case "INCREASE_LEVERAGE":
+		case "DEPOSIT":
+		case "DEPOSIT_AND_INCREASE_LEVERAGE": return require_sdk_accounts_intents_plan.planFinishClaimOnly(claimable);
+		default: throw new Error(`${intent.type} - not implemented`);
+	}
+}
+/**
+* Where a delayed intent ends up, worked out at the moment it is started.
+*
+* A request is only half a withdrawal, so the state it lands in is not the
+* answer to "what does this do to my position": the debt is still there, the
+* payout has not been made, and the position sits in a phantom token. What the
+* caller means is the far side — and that side can be walked now, because the
+* request already fixes the claim it will be finished from.
+*
+* So the same tail {@link planTail} builds at claim time is built here against
+* the account as the request leaves it, with the claim it is expected to bring,
+* and walked by the same realiser — with one substitution: routed legs are
+* priced by the oracle rather than the pathfinder, since the funds they trade
+* do not exist yet and no calldata is being produced. The result is an
+* estimate that the engine's guards are nevertheless applied to, so a request
+* that would strand the account is refused before it is sent rather than
+* discovered days later.
+*/
+async function projectTail(args) {
+	const { request, delayed, creditAccount, sdk, quotaReserve } = args;
+	const { claim } = delayed;
+	const queued = request.outputs.find((o) => o.isDelayed);
+	if (!queued || !claim) throw new Error("projectTail: the request queued nothing to claim");
+	const next = sliceAfter(creditAccount, delayed.afterRequest);
+	const steps = planTail({
+		intent: delayed.record,
+		claimable: projectedClaimable(request, queued.token, queued.amount, claim),
+		view: require_sdk_accounts_intents_view.accountView(next, sdk)
+	});
+	const { state, operations } = await require_sdk_accounts_intents_realize.realize(steps, {
+		creditAccount: next,
+		sdk,
+		slippage: 0,
+		quotaReserve,
+		paths: require_sdk_accounts_intents_utils_router_path.createOraclePaths({
+			sdk,
+			creditAccount: next
+		})
+	});
+	return {
+		state,
+		operations
+	};
+}
+/**
+* The matured withdrawal the tail will be built from, as the request implies
+* it: the phantom it created is burned and the venue's payout takes its place.
+* It carries no claim calls — those are read from the chain when the claim is
+* real, and nothing here is going to be sent.
+*/
+function projectedClaimable(request, phantom, phantomAmount, claim) {
+	return {
+		token: request.token,
+		withdrawalPhantomToken: phantom,
+		withdrawalTokenSpent: phantomAmount,
+		outputs: [{
+			token: claim.token,
+			amount: claim.amount,
+			isDelayed: false
+		}],
+		claimCalls: []
+	};
+}
+/**
+* The account as one walk left it, shaped as the slice the next walk reads.
+* Masks are carried over from the tokens the account already held; one it
+* picked up along the way has none to carry, which only the router slice
+* would have used.
+*/
+function sliceAfter(creditAccount, after) {
+	const masks = new Map(creditAccount.tokens.map((t) => [t.token.toLowerCase(), t.mask]));
+	return {
+		...creditAccount,
+		accountDebt: after.accountDebt,
+		tokens: after.assets.map((a) => {
+			const token = a.token.address.toLowerCase();
+			return {
+				token,
+				balance: a.value,
+				quota: after.quotas[token]?.balance ?? 0n,
+				mask: masks.get(token) ?? 0n,
+				success: true
+			};
+		})
+	};
+}
+//#endregion
+exports.planTail = planTail;
+exports.projectTail = projectTail;

package/dist/cjs/sdk/accounts/intents/testing/delayed.js

@@ -0,0 +1,50 @@
+const require_sdk_mock = require("./sdk-mock.js");
+const require_market = require("./market.js");
+//#region src/sdk/accounts/intents/testing/delayed.ts
+const FIXTURE_PHANTOM = "0xcccccccccccccccccccccccccccccccccccccccc";
+/** Claimed proceeds converted to UND (mirrors the mock price oracle). */
+function claimedValueInUnd(amount, token) {
+	return require_market.valueInUnd(amount, token);
+}
+/**
+* Mock sdk for a tail case. The phantom token inherits the claimed token's
+* decimals, so any 1:1 rescale through it stays the identity.
+*/
+function buildTailSdk(c, extras) {
+	const phantom = extras?.phantom ?? "0xcccccccccccccccccccccccccccccccccccccccc";
+	return require_market.buildMarketSdk({
+		...extras,
+		extraDecimals: {
+			...extras?.extraDecimals,
+			[phantom]: extras?.extraDecimals?.[c.claimedToken] ?? require_market.DECIMALS[c.claimedToken]
+		}
+	});
+}
+/** The matured withdrawal a tail case claims. */
+function buildClaimable(c) {
+	return {
+		token: c.claimedToken,
+		withdrawalPhantomToken: FIXTURE_PHANTOM,
+		withdrawalTokenSpent: c.claimedAmount,
+		outputs: [{
+			token: c.claimedToken,
+			amount: c.claimedAmount,
+			isDelayed: false
+		}],
+		claimCalls: [require_sdk_mock.MOCK_CLAIM_CALL]
+	};
+}
+//#endregion
+exports.ANY = require_market.ANY;
+exports.ANY2 = require_market.ANY2;
+exports.CREDIT_ACCOUNT = require_market.CREDIT_ACCOUNT;
+exports.CREDIT_FACADE = require_market.CREDIT_FACADE;
+exports.CREDIT_MANAGER = require_market.CREDIT_MANAGER;
+exports.FIXTURE_PHANTOM = FIXTURE_PHANTOM;
+exports.POS = require_market.POS;
+exports.RWA_ASSET = require_market.RWA_ASSET;
+exports.UND = require_market.UND;
+exports.buildClaimable = buildClaimable;
+exports.buildMarketSdk = require_market.buildMarketSdk;
+exports.buildTailSdk = buildTailSdk;
+exports.claimedValueInUnd = claimedValueInUnd;

package/dist/cjs/sdk/accounts/intents/testing/market.js

@@ -0,0 +1,167 @@
+const require_sdk_utils_formatter = require("../../../utils/formatter.js");
+require("../../../index.js");
+const require_sdk_mock = require("./sdk-mock.js");
+const UND = "0x3333333333333333333333333333333333333333";
+const ANY = "0x1111111111111111111111111111111111111111";
+const ANY2 = "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
+const RWA_ASSET = "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+/**
+* Position token that converts 1:1 with `UND` (same decimals, same price).
+*
+* The mock router echoes the input amount as the output amount, so a 1:1 pair is
+* the only way a swap leg's expected amounts stay decimals-correct. Use `POS`
+* for flows whose amounts cross a swap, and `ANY` where they do not.
+*/
+const POS = "0x2222222222222222222222222222222222222222";
+/** Second 1:1 token, for flows routing between two non-underlying tokens. */
+const POS2 = "0x4444444444444444444444444444444444444444";
+const CREDIT_MANAGER = "0xdddddddddddddddddddddddddddddddddddddddd";
+const CREDIT_FACADE = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+const CREDIT_ACCOUNT = "0xacacacacacacacacacacacacacacacacacacacac";
+const WALLET = "0xf0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0";
+const PRICES = {
+	[UND]: require_sdk_utils_formatter.toBN("2", 8),
+	[ANY]: require_sdk_utils_formatter.toBN("1", 8),
+	[ANY2]: require_sdk_utils_formatter.toBN("1", 8),
+	[RWA_ASSET]: require_sdk_utils_formatter.toBN("2", 8),
+	[POS]: require_sdk_utils_formatter.toBN("2", 8),
+	[POS2]: require_sdk_utils_formatter.toBN("2", 8)
+};
+const DECIMALS = {
+	[UND]: 8,
+	[ANY]: 18,
+	[ANY2]: 18,
+	[RWA_ASSET]: 8,
+	[POS]: 8,
+	[POS2]: 8
+};
+const QUOTAS = {
+	[ANY]: {
+		token: ANY,
+		rate: 500n,
+		limit: require_sdk_utils_formatter.toBN("999999999999999", 18),
+		isActive: true
+	},
+	[ANY2]: {
+		token: ANY2,
+		rate: 500n,
+		limit: require_sdk_utils_formatter.toBN("999999999999999", 18),
+		isActive: true
+	},
+	[RWA_ASSET]: {
+		token: RWA_ASSET,
+		rate: 500n,
+		limit: require_sdk_utils_formatter.toBN("999999999999999", 8),
+		isActive: true
+	},
+	[POS]: {
+		token: POS,
+		rate: 500n,
+		limit: require_sdk_utils_formatter.toBN("999999999999999", 8),
+		isActive: true
+	},
+	[POS2]: {
+		token: POS2,
+		rate: 500n,
+		limit: require_sdk_utils_formatter.toBN("999999999999999", 8),
+		isActive: true
+	}
+};
+const LIQUIDATION_THRESHOLDS = {
+	[UND]: 9800,
+	[ANY]: 9200,
+	[ANY2]: 9200,
+	[RWA_ASSET]: 9200,
+	[POS]: 9200,
+	[POS2]: 9200
+};
+const MAX_DEBT = require_sdk_utils_formatter.toBN("200000", 8);
+/** Mock SDK on the shared fixture market. */
+function buildMarketSdk(extras) {
+	return require_sdk_mock.buildMockSdk({
+		prices: {
+			...PRICES,
+			...extras?.extraPrices
+		},
+		reservePrices: extras?.reservePrices,
+		decimals: {
+			...DECIMALS,
+			...extras?.extraDecimals
+		},
+		quotas: extras?.quotas ?? QUOTAS,
+		liquidationThresholds: LIQUIDATION_THRESHOLDS,
+		maxDebt: MAX_DEBT,
+		minDebt: extras?.minDebt,
+		creditManager: CREDIT_MANAGER,
+		creditFacade: CREDIT_FACADE,
+		underlying: UND,
+		rwaAssets: extras?.rwaAssets,
+		phantoms: extras?.phantoms,
+		creditAccounts: extras?.creditAccounts,
+		delayed: extras?.delayed,
+		facadePaused: extras?.facadePaused,
+		poolPaused: extras?.poolPaused,
+		expirationDate: extras?.expirationDate,
+		timestamp: extras?.timestamp,
+		availableLiquidity: extras?.availableLiquidity,
+		debtLimitAvailable: extras?.debtLimitAvailable,
+		maxDebtPerBlockMultiplier: extras?.maxDebtPerBlockMultiplier,
+		forbiddenTokens: extras?.forbiddenTokens,
+		strategyTargetCollateral: POS
+	});
+}
+/** Converts an amount to UND at fixture prices (mirrors the mock oracle). */
+function valueInUnd(amount, token, overrides) {
+	const prices = {
+		...PRICES,
+		...overrides?.prices
+	};
+	const decimals = {
+		...DECIMALS,
+		...overrides?.decimals
+	};
+	return amount * prices[token] * 10n ** BigInt(8) / (prices[UND] * 10n ** BigInt(decimals[token]));
+}
+/** Token entry for a fixture CA, with quota defaulting to zero. */
+function caToken(token, balance, quota = 0n) {
+	return {
+		token,
+		balance,
+		quota,
+		mask: 0n,
+		success: true
+	};
+}
+/** Bare CA slice on the fixture market. */
+function buildFixtureCreditAccount(args) {
+	return {
+		creditAccount: CREDIT_ACCOUNT,
+		creditManager: CREDIT_MANAGER,
+		creditFacade: CREDIT_FACADE,
+		underlying: UND,
+		enabledTokensMask: 0n,
+		totalDebtUSD: 0n,
+		accountDebt: args.accountDebt,
+		tokens: args.tokens
+	};
+}
+//#endregion
+exports.ANY = ANY;
+exports.ANY2 = ANY2;
+exports.CREDIT_ACCOUNT = CREDIT_ACCOUNT;
+exports.CREDIT_FACADE = CREDIT_FACADE;
+exports.CREDIT_MANAGER = CREDIT_MANAGER;
+exports.DECIMALS = DECIMALS;
+exports.LIQUIDATION_THRESHOLDS = LIQUIDATION_THRESHOLDS;
+exports.MAX_DEBT = MAX_DEBT;
+exports.POS = POS;
+exports.POS2 = POS2;
+exports.PRICES = PRICES;
+exports.QUOTAS = QUOTAS;
+exports.RWA_ASSET = RWA_ASSET;
+exports.UND = UND;
+exports.WALLET = WALLET;
+exports.buildFixtureCreditAccount = buildFixtureCreditAccount;
+exports.buildMarketSdk = buildMarketSdk;
+exports.caToken = caToken;
+exports.valueInUnd = valueInUnd;