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

package/dist/esm/sdk/accounts/intents/testing/sdk-mock.js

@@ -1,3 +1,6 @@
+import "../../../constants/math.js";
+import "../../../constants/index.js";
+import { PositionsService } from "../../../positions/PositionsService.js";
 import { vi } from "vitest";
 //#region src/sdk/accounts/intents/testing/sdk-mock.ts
 /**
@@ -6,19 +9,19 @@ import { vi } from "vitest";
 * The service resolves all market data through `OnchainSDK`
 * (`marketRegister`, `tokensMeta`, `accounts`). `buildMockSdk` builds a mock
 * from plain records; assemble mocks ECHO recognizable sentinel calls derived
-* from their inputs, so `result.instant.calls` pins down which ops reached the
+* from their inputs, so `result.calls` pins down which ops reached the
 * assembler and in which order.
 */
-/** Fixture `claimableWithdrawal.claimCalls` content; echoes through claim ops. */
-const MOCK_CLAIM_CALL = {
-	target: "0x1111111111111111111111111111111111111111",
-	callData: "0x"
-};
-/** Recognizable router call embedded in close path results. */
+/** Recognizable router call embedded in routed leg results. */
 const MOCK_ROUTER_CALL = {
 	target: "0x9999999999999999999999999999999999999999",
 	callData: "0x"
 };
+/** Router call of the many-to-one leg an exit routes. */
+const MOCK_CLOSE_CALL = {
+	target: "0x9595959595959595959595959595959595959595",
+	callData: "0x"
+};
 /** Returned by the `getRWAWrapCalls` mock; passes through per wrap op. */
 const MOCK_RWA_WRAP_CALL = {
 	target: "0x8888888888888888888888888888888888888888",
@@ -29,9 +32,14 @@ const MOCK_RWA_UNWRAP_CALL = {
 	target: "0x7777777777777777777777777777777777777777",
 	callData: "0x"
 };
-/** Returned by the `assembleCloseCreditAccountCalls` mock. */
-const MOCK_CLOSE_CALL = {
-	target: "0x5555555555555555555555555555555555555555",
+/** Fixture `claimableWithdrawal.claimCalls` content; echoes through claim ops. */
+const MOCK_CLAIM_CALL = {
+	target: "0x1111111111111111111111111111111111111111",
+	callData: "0x"
+};
+/** Fixture `requestableWithdrawal.requestCalls`; echoes through request ops. */
+const MOCK_REQUEST_CALL = {
+	target: "0x2222222222222222222222222222222222222222",
 	callData: "0x"
 };
 /** One sentinel call per plain encodable op type. */
@@ -77,30 +85,99 @@ function buildMockSdk(args) {
 		if (fromPrice === void 0 || toPrice === void 0) throw new Error(`mock priceOracle: missing price for ${from} or ${target}`);
 		return amount * fromPrice * 10n ** BigInt(decimalsOf(target)) / (toPrice * 10n ** BigInt(decimalsOf(from)));
 	};
-	const quotas = { values: () => Object.values(args.quotas).map((q) => ({
+	const fullQuota = (q) => ({
 		cumulativeIndexLU: 0n,
 		totalQuoted: 0n,
 		quotaIncreaseFee: 0n,
 		...q
-	})) };
-	const liquidationThresholds = { entries: () => Object.entries(args.liquidationThresholds) };
+	});
+	const quotaOf = (token) => args.quotas[token.toLowerCase()] ?? args.quotas[token];
+	const quotas = {
+		values: () => Object.values(args.quotas).map(fullQuota),
+		get: (token) => {
+			const q = quotaOf(token);
+			return q === void 0 ? void 0 : fullQuota(q);
+		}
+	};
+	const liquidationThresholds = {
+		entries: () => Object.entries(args.liquidationThresholds),
+		get: (token) => args.liquidationThresholds[token.toLowerCase()] ?? args.liquidationThresholds[token]
+	};
+	const mainPriceOf = (token) => {
+		const key = token.toLowerCase();
+		const price = args.prices[key] ?? args.prices[token];
+		if (price === void 0) throw new Error(`mock priceOracle: missing main price for ${token}`);
+		return price;
+	};
+	const reservePriceOf = (token) => {
+		const key = token.toLowerCase();
+		const price = args.reservePrices?.[key] ?? args.reservePrices?.[token];
+		if (price === void 0) throw new Error(`mock priceOracle: missing reserve price for ${token}`);
+		return price;
+	};
+	const poolPaused = args.poolPaused ?? false;
 	const market = {
-		priceOracle: { convert },
+		priceOracle: {
+			convert,
+			mainPrice: mainPriceOf,
+			reservePrice: reservePriceOf,
+			convertToUSD: (token, amount) => {
+				const from = token.toLowerCase();
+				const price = args.prices[from] ?? args.prices[token];
+				if (price === void 0) throw new Error(`mock priceOracle: missing price for ${from}`);
+				return amount * price / 10n ** BigInt(decimalsOf(from));
+			},
+			safeConvertToUSD: (token, amount) => {
+				const from = token.toLowerCase();
+				const price = args.prices[from] ?? args.prices[token];
+				if (price === void 0) return null;
+				return amount * price / 10n ** BigInt(decimalsOf(from));
+			}
+		},
 		pool: {
-			pqk: { quotas },
+			pqk: {
+				quotas,
+				quotaRate: (token) => Number(quotaOf(token)?.rate ?? 0n),
+				hasActiveQuota: (token) => {
+					const q = quotaOf(token);
+					return !!q?.isActive && q.limit > 0n;
+				}
+			},
+			pool: {
+				baseInterestRate: args.baseInterestRate ?? 0n,
+				isPaused: poolPaused,
+				availableLiquidity: args.availableLiquidity ?? 115792089237316195423570985008687907853269984665640564039457584007913129639935n,
+				creditManagerDebtParams: { get: () => ({ available: args.debtLimitAvailable ?? 115792089237316195423570985008687907853269984665640564039457584007913129639935n }) }
+			},
+			isPaused: poolPaused,
 			underlying: args.underlying
 		}
 	};
+	const collateralTokens = [args.underlying.toLowerCase(), ...Object.keys(args.liquidationThresholds).map((t) => t.toLowerCase()).filter((t) => t !== args.underlying.toLowerCase())];
+	const forbidden = new Set((args.forbiddenTokens ?? []).map((t) => t.toLowerCase()));
+	const forbiddenTokensMask = collateralTokens.reduce((mask, token, i) => forbidden.has(token) ? mask | 1n << BigInt(i) : mask, 0n);
+	const facadePaused = args.facadePaused ?? false;
+	const expirationDate = args.expirationDate ?? 0;
 	const creditManagerSuite = {
 		creditManager: {
 			address: args.creditManager,
 			liquidationThresholds,
-			collateralTokens: []
+			collateralTokens,
+			feeInterest: args.feeInterest ?? 0
 		},
 		creditFacade: {
 			address: args.creditFacade,
-			maxDebt: args.maxDebt
-		}
+			maxDebt: args.maxDebt,
+			minDebt: args.minDebt ?? 0n,
+			isPaused: facadePaused,
+			expirable: expirationDate > 0,
+			expirationDate,
+			maxDebtPerBlockMultiplier: args.maxDebtPerBlockMultiplier ?? 2,
+			forbiddenTokensMask
+		},
+		market,
+		isPaused: facadePaused || poolPaused,
+		isExpired: expirationDate > 0 && expirationDate < (args.timestamp ?? 0)
 	};
 	const routeCalls = (tokenIn, tokenOut) => {
 		const underlying = args.underlying.toLowerCase();
@@ -112,10 +189,6 @@ function buildMockSdk(args) {
 		return [MOCK_ROUTER_CALL];
 	};
 	const router = {
-		findBestClosePath: vi.fn(async () => {
-			if (!args.closePath) throw new Error("mock router: closePath not configured");
-			return args.closePath;
-		}),
 		findOneTokenPath: vi.fn(async ({ amount, tokenIn, tokenOut }) => ({
 			amount,
 			minAmount: amount,
@@ -130,20 +203,77 @@ function buildMockSdk(args) {
 				calls: routeCalls(tokenIn, target)
 			};
 		}),
-		findOpenStrategyPath: vi.fn(async ({ expectedBalances, leftoverBalances }) => {
-			const spent = expectedBalances.reduce((acc, a) => acc + a.balance, 0n) - leftoverBalances.reduce((acc, a) => acc + a.balance, 0n);
+		findOpenStrategyPath: vi.fn(async ({ expectedBalances, leftoverBalances, target }) => {
+			const targetLc = target.toLowerCase();
+			const leftover = new Map(leftoverBalances.map((a) => [a.token.toLowerCase(), a.balance]));
+			const balances = {};
+			let amount = 0n;
+			for (const a of expectedBalances) {
+				const token = a.token.toLowerCase();
+				if (token === targetLc) {
+					balances[token] = (balances[token] ?? 0n) + a.balance;
+					continue;
+				}
+				const keep = leftover.get(token) ?? 0n;
+				const spend = a.balance > keep ? a.balance - keep : 0n;
+				balances[token] = a.balance - spend;
+				amount += convert(token, targetLc, spend);
+			}
+			balances[targetLc] = (balances[targetLc] ?? 0n) + amount;
 			return {
-				amount: spent,
-				minAmount: spent,
-				calls: [MOCK_ROUTER_CALL],
-				minAssets: [],
-				averageAssets: []
+				amount,
+				minAmount: amount,
+				balances,
+				minBalances: { ...balances },
+				calls: [MOCK_ROUTER_CALL]
+			};
+		}),
+		findBestClosePath: vi.fn(async ({ balances }) => {
+			const underlying = args.underlying.toLowerCase();
+			const sold = (balances?.expectedBalances ?? []).filter((a) => a.token.toLowerCase() !== underlying && a.balance > 10n);
+			const amount = sold.reduce((acc, a) => acc + convert(a.token, underlying, a.balance), 0n);
+			return {
+				amount,
+				minAmount: amount,
+				underlyingBalance: amount,
+				calls: sold.length === 0 ? [] : [MOCK_CLOSE_CALL]
 			};
 		})
 	};
-	return {
+	const phantoms = new Set((args.phantoms ?? []).map((t) => t.toLowerCase()));
+	const venuesOf = (token) => args.delayed?.[token.toLowerCase()] ?? [];
+	const withdrawalCompressor = args.delayed ? { findWithdrawableAssets: vi.fn(async (creditManager, token) => venuesOf(token).map((v) => ({
+		creditManager,
+		token,
+		withdrawalPhantomToken: v.withdrawalPhantomToken,
+		underlying: v.underlying ?? args.underlying,
+		withdrawalLength: 172800n
+	}))) } : void 0;
+	const previewDelayedWithdrawal = vi.fn(async ({ token, amount, withdrawalPhantomToken }) => {
+		const venue = venuesOf(token).find((v) => v.withdrawalPhantomToken === withdrawalPhantomToken) ?? venuesOf(token)[0];
+		if (!venue) throw new Error(`mock compressor: ${token} has no delayed route`);
+		return {
+			token,
+			amountIn: amount,
+			outputs: venue.outputs?.(amount) ?? [{
+				token: venue.withdrawalPhantomToken,
+				amount,
+				isDelayed: true
+			}],
+			requestCalls: [MOCK_REQUEST_CALL],
+			claimableAt: venue.claimableAt ?? 172800n
+		};
+	});
+	const sdk = {
+		chainId: 1,
+		currentBlock: 1n,
+		timestamp: args.timestamp ?? 0,
+		withdrawalCompressor,
 		tokensMeta: {
-			get: (token) => ({ decimals: decimalsOf(token) }),
+			get: (token) => ({
+				decimals: decimalsOf(token),
+				contractType: phantoms.has(token.toLowerCase()) ? "PHANTOM_TOKEN::SECURITIZE_RD" : void 0
+			}),
 			rwaUnderlyings: { get: (token) => {
 				const asset = args.rwaAssets?.[token.toLowerCase()];
 				return asset ? { asset } : void 0;
@@ -155,18 +285,47 @@ function buildMockSdk(args) {
 		},
 		routerFor: vi.fn(() => router),
 		accounts: {
+			getCreditAccountData: vi.fn(async (address) => {
+				const slice = args.creditAccounts?.find((ca) => ca.creditAccount.toLowerCase() === address.toLowerCase());
+				return slice ? payloadOf(slice) : void 0;
+			}),
 			assembleCaOperations: vi.fn(({ operations }) => operations.flatMap(echoEncodableOpCalls)),
 			prepareIncreaseDebt: vi.fn(() => CA_OP_CALLS.increaseDebt),
 			prepareChangeDebt: vi.fn(() => CA_OP_CALLS.decreaseDebt),
 			prepareAddCollateral: vi.fn(() => [CA_OP_CALLS.addCollateral]),
 			prepareWithdrawToken: vi.fn(() => CA_OP_CALLS.withdrawCollateral),
 			prepareUpdateQuotas: vi.fn(() => [CA_OP_CALLS.changeQuota]),
-			assembleClaimDelayedCalls: vi.fn(({ claimableNow }) => [...claimableNow.claimCalls]),
-			assembleCloseCreditAccountCalls: vi.fn(async () => [MOCK_CLOSE_CALL]),
 			assembleRWAWrapCalls: vi.fn(async () => [MOCK_RWA_WRAP_CALL]),
-			assembleRWAUnwrapCalls: vi.fn(async () => [MOCK_RWA_UNWRAP_CALL])
+			assembleRWAUnwrapCalls: vi.fn(async () => [MOCK_RWA_UNWRAP_CALL]),
+			previewDelayedWithdrawal,
+			assembleStartDelayedWithdrawalCalls: vi.fn(({ preview }) => [...preview.requestCalls]),
+			assembleClaimDelayedCalls: vi.fn(({ claimableNow }) => [...claimableNow.claimCalls])
 		}
 	};
+	Object.assign(sdk, { positions: new PositionsService(sdk) });
+	return sdk;
+}
+/** A full account payload carrying exactly what the slice builder reads back. */
+function payloadOf(slice) {
+	return {
+		creditAccount: slice.creditAccount,
+		creditManager: slice.creditManager,
+		creditFacade: slice.creditFacade,
+		underlying: slice.underlying,
+		owner: slice.creditAccount,
+		expirationDate: 0,
+		enabledTokensMask: slice.enabledTokensMask,
+		debt: slice.accountDebt,
+		accruedInterest: 0n,
+		accruedFees: 0n,
+		totalDebtUSD: slice.totalDebtUSD,
+		totalValueUSD: 0n,
+		twvUSD: 0n,
+		totalValue: 0n,
+		healthFactor: 0n,
+		success: true,
+		tokens: slice.tokens
+	};
 }
 //#endregion
-export { CA_OP_CALLS, MOCK_CLAIM_CALL, MOCK_CLOSE_CALL, MOCK_ROUTER_CALL, MOCK_RWA_UNWRAP_CALL, MOCK_RWA_WRAP_CALL, buildMockSdk };
+export { CA_OP_CALLS, MOCK_CLAIM_CALL, MOCK_CLOSE_CALL, MOCK_REQUEST_CALL, MOCK_ROUTER_CALL, MOCK_RWA_UNWRAP_CALL, MOCK_RWA_WRAP_CALL, buildMockSdk };

package/dist/esm/sdk/accounts/intents/tests/add-collateral.fixtures.js

@@ -0,0 +1,110 @@
+import { ANY, RWA_ASSET, UND, buildFixtureCreditAccount, buildMarketSdk, caToken, valueInUnd } from "../testing/market.js";
+//#region src/sdk/accounts/intents/tests/add-collateral.fixtures.ts
+/**
+* Start add-collateral fixtures (intent 5).
+*
+* Only the position token can be deposited, so every case is a single
+* `addCollateral` plus the quota increase implied by the new balance. Debt never
+* moves.
+*/
+/** Quota bought for a freshly obtained balance: value in UND scaled by its LT. */
+function quotaFor(amount, token, lt) {
+	return valueInUnd(amount, token) * lt / 10000n;
+}
+const LT_ANY = 9200n;
+/** 1000 UND of pre-existing collateral, 500 UND of debt. */
+const BASE_UND = 100000000000n;
+const DEBT = 50000000000n;
+/** 2000 ANY = 1000 UND at fixture prices. */
+const ADD_ANY = 2000000000000000000000n;
+/** 500 UND. */
+const ADD_UND = 50000000000n;
+/** 1000 RWA_ASSET = 1000 UND at fixture prices. */
+const ADD_RWA = 100000000000n;
+const QUOTA_ANY = quotaFor(ADD_ANY, ANY, LT_ANY);
+const QUOTA_RWA = quotaFor(ADD_RWA, RWA_ASSET, LT_ANY);
+/** Position token with a quota: addCollateral then buy quota for it. */
+const case_position_token = {
+	intent: {
+		type: "ADD_COLLATERAL",
+		token: ANY,
+		amount: ADD_ANY
+	},
+	tokens: [caToken(UND, BASE_UND)],
+	accountDebt: DEBT,
+	totalValue: BASE_UND + valueInUnd(ADD_ANY, ANY),
+	ops: [{
+		type: "addCollateral",
+		token: ANY,
+		amount: ADD_ANY,
+		value: void 0
+	}, {
+		type: "changeQuota",
+		quotaIncrease: [{
+			token: ANY,
+			balance: QUOTA_ANY
+		}],
+		quotaDecrease: [],
+		desiredQuota: {}
+	}]
+};
+/** Underlying has no quota, so the flow is a bare addCollateral. */
+const case_underlying = {
+	intent: {
+		type: "ADD_COLLATERAL",
+		token: UND,
+		amount: ADD_UND
+	},
+	tokens: [caToken(ANY, ADD_ANY, QUOTA_ANY)],
+	accountDebt: DEBT,
+	totalValue: valueInUnd(ADD_ANY, ANY) + ADD_UND,
+	ops: [{
+		type: "addCollateral",
+		token: UND,
+		amount: ADD_UND,
+		value: void 0
+	}]
+};
+/** RWA market: the rwa asset is deposited as-is, with no wrap leg. */
+const case_rwa_asset = {
+	intent: {
+		type: "ADD_COLLATERAL",
+		token: RWA_ASSET,
+		amount: ADD_RWA
+	},
+	tokens: [caToken(UND, BASE_UND)],
+	accountDebt: DEBT,
+	totalValue: BASE_UND + valueInUnd(ADD_RWA, RWA_ASSET),
+	ops: [{
+		type: "addCollateral",
+		token: RWA_ASSET,
+		amount: ADD_RWA,
+		value: void 0
+	}, {
+		type: "changeQuota",
+		quotaIncrease: [{
+			token: RWA_ASSET,
+			balance: QUOTA_RWA
+		}],
+		quotaDecrease: [],
+		desiredQuota: {}
+	}],
+	rwaAssets: { [UND]: RWA_ASSET }
+};
+function buildAddCollateralSdk(c) {
+	return buildMarketSdk({ rwaAssets: c.rwaAssets });
+}
+function buildAddCollateralProps(c, sdk) {
+	return {
+		intent: c.intent,
+		creditAccount: buildFixtureCreditAccount({
+			accountDebt: c.accountDebt,
+			tokens: c.tokens
+		}),
+		sdk,
+		quotaReserve: void 0,
+		slippage: void 0
+	};
+}
+//#endregion
+export { ADD_ANY, ADD_RWA, ADD_UND, BASE_UND, DEBT, LT_ANY, QUOTA_ANY, QUOTA_RWA, buildAddCollateralProps, buildAddCollateralSdk, case_position_token, case_rwa_asset, case_underlying };

package/dist/esm/sdk/accounts/intents/tests/adjust-leverage.fixtures.js

@@ -0,0 +1,234 @@
+import { POS, RWA_ASSET, UND, buildFixtureCreditAccount, buildMarketSdk, caToken } from "../testing/market.js";
+//#region src/sdk/accounts/intents/tests/adjust-leverage.fixtures.ts
+/**
+* Start adjust-leverage fixtures (intent 6), collateral held fixed.
+*
+* Every case starts from 1000 UND of TVL against 500 UND of debt, i.e. 500 UND
+* of collateral at 2x. Because collateral is the invariant, a target of 3x means
+* `D1 = 500 * 2 = 1000` and a target of 2x from 3x means repaying back to 500.
+*
+* `POS` is used as the position token: it converts 1:1 with `UND`, which is the
+* only way the mock router's echo-the-input behaviour stays decimals-honest.
+*/
+const LT = 9200n;
+/** 500 UND. */
+const STEP = 50000000000n;
+/** 1000 UND. */
+const TVL_2X = 100000000000n;
+/** 1500 UND. */
+const TVL_3X = 150000000000n;
+const DEBT_2X = STEP;
+const DEBT_3X = TVL_2X;
+/** Leverage targets in LEVERAGE_DECIMALS (100n = 1x). */
+const LEV_2X = 200n;
+const LEV_3X = 300n;
+const quotaOf = (balance) => balance * LT / 10000n;
+const QUOTA_1000 = quotaOf(TVL_2X);
+const QUOTA_1500 = quotaOf(TVL_3X);
+/** Quota ops carry signed deltas. */
+const QUOTA_UP = QUOTA_1500 - QUOTA_1000;
+const QUOTA_DOWN = QUOTA_1000 - QUOTA_1500;
+/** 2x → 3x: borrow the difference and buy the position token with it. */
+const case_increase = {
+	intent: {
+		type: "ADJUST_LEVERAGE",
+		targetLeverage: LEV_3X,
+		token: POS
+	},
+	tokens: [caToken(POS, TVL_2X, QUOTA_1000)],
+	accountDebt: DEBT_2X,
+	totalValue: TVL_3X,
+	accountDebtAfter: DEBT_3X,
+	ops: [
+		{
+			type: "increaseDebt",
+			amount: STEP
+		},
+		{
+			type: "swap",
+			from: [{
+				token: UND,
+				balance: STEP
+			}],
+			tokenOut: POS,
+			amountOut: STEP
+		},
+		{
+			type: "changeQuota",
+			quotaIncrease: [{
+				token: POS,
+				balance: QUOTA_UP
+			}],
+			quotaDecrease: [],
+			desiredQuota: {}
+		}
+	]
+};
+/** Position token is the underlying: borrowing alone reaches the target. */
+const case_increase_underlying = {
+	intent: {
+		type: "ADJUST_LEVERAGE",
+		targetLeverage: LEV_3X,
+		token: UND
+	},
+	tokens: [caToken(UND, TVL_2X)],
+	accountDebt: DEBT_2X,
+	totalValue: TVL_3X,
+	accountDebtAfter: DEBT_3X,
+	ops: [{
+		type: "increaseDebt",
+		amount: STEP
+	}]
+};
+/** RWA market: the borrowed wrapper is unwrapped instead of swapped. */
+const case_increase_rwa = {
+	intent: {
+		type: "ADJUST_LEVERAGE",
+		targetLeverage: LEV_3X,
+		token: RWA_ASSET
+	},
+	tokens: [caToken(RWA_ASSET, TVL_2X, QUOTA_1000)],
+	accountDebt: DEBT_2X,
+	totalValue: TVL_3X,
+	accountDebtAfter: DEBT_3X,
+	ops: [
+		{
+			type: "increaseDebt",
+			amount: STEP
+		},
+		{
+			type: "unwrapRwaCollateral",
+			tokenIn: UND,
+			amount: STEP,
+			tokenOut: RWA_ASSET,
+			amountOut: STEP
+		},
+		{
+			type: "changeQuota",
+			quotaIncrease: [{
+				token: RWA_ASSET,
+				balance: QUOTA_UP
+			}],
+			quotaDecrease: [],
+			desiredQuota: {}
+		}
+	],
+	rwaAssets: { [UND]: RWA_ASSET }
+};
+/** 3x → 2x: sell position token, repay with the proceeds. */
+const case_decrease = {
+	intent: {
+		type: "ADJUST_LEVERAGE",
+		targetLeverage: LEV_2X,
+		token: POS
+	},
+	tokens: [caToken(POS, TVL_3X, QUOTA_1500)],
+	accountDebt: DEBT_3X,
+	totalValue: TVL_2X,
+	accountDebtAfter: DEBT_2X,
+	ops: [
+		{
+			type: "swap",
+			from: [{
+				token: POS,
+				balance: STEP
+			}],
+			tokenOut: UND,
+			amountOut: STEP
+		},
+		{
+			type: "decreaseDebt",
+			amount: STEP
+		},
+		{
+			type: "changeQuota",
+			quotaIncrease: [],
+			quotaDecrease: [{
+				token: POS,
+				balance: QUOTA_DOWN
+			}],
+			desiredQuota: {}
+		}
+	]
+};
+/** Idle underlying already covers the repayment, so no swap leg is built. */
+const case_decrease_from_idle_underlying = {
+	intent: {
+		type: "ADJUST_LEVERAGE",
+		targetLeverage: LEV_2X,
+		token: POS
+	},
+	tokens: [caToken(POS, TVL_2X, QUOTA_1000), caToken(UND, STEP)],
+	accountDebt: DEBT_3X,
+	totalValue: TVL_2X,
+	accountDebtAfter: DEBT_2X,
+	ops: [{
+		type: "decreaseDebt",
+		amount: STEP
+	}]
+};
+/** RWA market: the asset is wrapped back into the underlying to repay. */
+const case_decrease_rwa = {
+	intent: {
+		type: "ADJUST_LEVERAGE",
+		targetLeverage: LEV_2X,
+		token: RWA_ASSET
+	},
+	tokens: [caToken(RWA_ASSET, TVL_3X, QUOTA_1500)],
+	accountDebt: DEBT_3X,
+	totalValue: TVL_2X,
+	accountDebtAfter: DEBT_2X,
+	ops: [
+		{
+			type: "wrapRwaCollateral",
+			tokenIn: RWA_ASSET,
+			amount: STEP,
+			tokenOut: UND,
+			amountOut: STEP
+		},
+		{
+			type: "decreaseDebt",
+			amount: STEP
+		},
+		{
+			type: "changeQuota",
+			quotaIncrease: [],
+			quotaDecrease: [{
+				token: RWA_ASSET,
+				balance: QUOTA_DOWN
+			}],
+			desiredQuota: {}
+		}
+	],
+	rwaAssets: { [UND]: RWA_ASSET }
+};
+/** Target equals the current leverage: nothing to do. */
+const case_noop = {
+	intent: {
+		type: "ADJUST_LEVERAGE",
+		targetLeverage: LEV_2X,
+		token: POS
+	},
+	tokens: [caToken(POS, TVL_2X, QUOTA_1000)],
+	accountDebt: DEBT_2X,
+	totalValue: TVL_2X,
+	accountDebtAfter: DEBT_2X,
+	ops: []
+};
+function buildAdjustLeverageSdk(c) {
+	return buildMarketSdk({ rwaAssets: c.rwaAssets });
+}
+function buildAdjustLeverageProps(c, sdk) {
+	return {
+		intent: c.intent,
+		creditAccount: buildFixtureCreditAccount({
+			accountDebt: c.accountDebt,
+			tokens: c.tokens
+		}),
+		sdk,
+		quotaReserve: void 0,
+		slippage: void 0
+	};
+}
+//#endregion
+export { DEBT_2X, DEBT_3X, LEV_2X, LEV_3X, QUOTA_1000, QUOTA_1500, QUOTA_DOWN, QUOTA_UP, STEP, TVL_2X, TVL_3X, buildAdjustLeverageProps, buildAdjustLeverageSdk, case_decrease, case_decrease_from_idle_underlying, case_decrease_rwa, case_increase, case_increase_rwa, case_increase_underlying, case_noop };