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

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

@@ -0,0 +1,220 @@
+import { MIN_INT96 } from "../../../constants/math.js";
+import { MOCK_CLAIM_CALL } from "../testing/sdk-mock.js";
+import { ANY, CREDIT_ACCOUNT, CREDIT_FACADE, CREDIT_MANAGER, POS, POS2, RWA_ASSET, UND, buildMarketSdk } from "../testing/market.js";
+import { buildTailSdk } from "../testing/delayed.js";
+//#region src/sdk/accounts/intents/tests/finish-decrease-leverage.fixtures.ts
+/**
+* Decrease-leverage tail fixtures, ported from intent-calculator
+* `decreaseLeverage.flowFixtures.ts` (tail cases only).
+*/
+/** Repay for L0 → L1_FOUR with fixed collateral. */
+const DECREASE_REPAY = 1000000000000n;
+/** CA ANY spent to fund {@link DECREASE_REPAY} (oracle: ANY@$1 → UND@$2). */
+const DECREASE_AMOUNT_S = 20000000000000000000000n;
+/** Post-claim metrics after claim repay (fixed C). */
+const DECREASE_POST_T = 4000000000000n;
+const DECREASE_POST_D = 3000000000000n;
+/** Pre-repay account debt (D0). */
+const DECREASE_PRE_D = 4000000000000n;
+/** Pre-repay TVL with claim proceeds still on CA (T0). */
+const DECREASE_PRE_T = 5000000000000n;
+const PHANTOM = "0xb1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1";
+function buildDecreaseSdk(args) {
+	return buildTailSdk({ claimedToken: args.claimedToken }, {
+		rwaAssets: args.rwaAssets,
+		phantom: PHANTOM
+	});
+}
+/** The matured withdrawal these fixtures claim. */
+function buildDecreaseClaimable(args) {
+	return {
+		token: args.claimedToken,
+		withdrawalPhantomToken: PHANTOM,
+		withdrawalTokenSpent: args.claimedAmount,
+		outputs: [{
+			token: args.claimedToken,
+			amount: args.claimedAmount,
+			isDelayed: false
+		}],
+		claimCalls: [MOCK_CLAIM_CALL]
+	};
+}
+function buildDecreaseTailProps(args) {
+	return {
+		intent: { type: "DECREASE_LEVERAGE" },
+		creditAccount: {
+			creditAccount: CREDIT_ACCOUNT,
+			creditManager: CREDIT_MANAGER,
+			creditFacade: CREDIT_FACADE,
+			underlying: UND,
+			enabledTokensMask: 0n,
+			totalDebtUSD: 0n,
+			accountDebt: DECREASE_PRE_D,
+			tokens: args.tokens ?? [{
+				token: "0xb1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1",
+				balance: args.claimedAmount,
+				quota: 0n,
+				mask: 0n,
+				success: true
+			}, {
+				token: "0x3333333333333333333333333333333333333333",
+				balance: 4000000000000n,
+				quota: 0n,
+				mask: 0n,
+				success: true
+			}]
+		},
+		sdk: args.sdk,
+		quotaReserve: void 0,
+		claimable: buildDecreaseClaimable(args),
+		slippage: args.slippage ?? 50
+	};
+}
+/** Convenience: props for a claimed token/amount. */
+function buildDecreaseOnchainTailProps(args) {
+	const sdk = buildDecreaseSdk({
+		claimedToken: args.claimedToken,
+		rwaAssets: args.rwaAssets
+	});
+	return buildDecreaseTailProps({
+		claimedToken: args.claimedToken,
+		claimedAmount: args.claimedAmount,
+		sdk,
+		slippage: args.slippage
+	});
+}
+const M7_LT = 9200n;
+/** Quota the matrix cases give a balance: balance * LT / PERCENTAGE_FACTOR. */
+const m7QuotaOf = (balance) => balance * M7_LT / 10000n;
+/** Matrix baseline debt: 8U. */
+const M7_DEBT = 800000000n;
+/** Delayed deleverage 5x → 3x repays 4U. */
+const M7_DD = 400000000n;
+/** Position left after the leading half redeemed 4A of the 10A. */
+const M7_POS_LEFT = 600000000n;
+/** 4U claimed in `ANY` (priced 1 against `UND` priced 2): 8 ANY. */
+const M7_CLAIM_ANY = 8000000000000000000n;
+/** Quotable withdrawal phantom: `POS2`, 1:1 with `POS`. */
+const M7_PHANTOM = POS2;
+/** The claim op every matrix tail starts with. */
+function m7ClaimOp(claimedToken, claimedAmount) {
+	return {
+		type: "claimDelayedWithdrawal",
+		token: POS,
+		withdrawalPhantomToken: M7_PHANTOM,
+		withdrawalTokenSpent: M7_DD,
+		outputs: [{
+			token: claimedToken,
+			amount: claimedAmount,
+			isDelayed: false
+		}]
+	};
+}
+/**
+* Quota op every matrix tail ends with: the phantom is fully spent, so its
+* quota is reset (the `MIN_INT96` sentinel encodes "reset" in quota deltas).
+*/
+function m7PhantomQuotaResetOp() {
+	return {
+		type: "changeQuota",
+		quotaIncrease: [],
+		quotaDecrease: [{
+			token: M7_PHANTOM,
+			balance: MIN_INT96
+		}],
+		desiredQuota: {}
+	};
+}
+/** Matrix 7.2 tail — the claim pays `UND`; everything claimed repays the debt. */
+const case_matrix_7_2_tail = {
+	claimedToken: UND,
+	claimedAmount: M7_DD,
+	totalValue: M7_POS_LEFT,
+	ops: [
+		m7ClaimOp(UND, M7_DD),
+		{
+			type: "decreaseDebt",
+			amount: M7_DD
+		},
+		m7PhantomQuotaResetOp()
+	]
+};
+/**
+* Matrix 7.3 tail — the claim pays `ANY`, swapped into `UND` before repaying.
+* The swap output (`amountOut`) comes from the router quote, which the spec
+* mocks to a realistic 1:1-in-value path — the echo router would otherwise
+* repay its raw input as debt (same override as case D above).
+*/
+const case_matrix_7_3_tail = {
+	claimedToken: ANY,
+	claimedAmount: M7_CLAIM_ANY,
+	totalValue: M7_POS_LEFT,
+	ops: [
+		m7ClaimOp(ANY, M7_CLAIM_ANY),
+		{
+			type: "swap",
+			from: [{
+				token: ANY,
+				balance: M7_CLAIM_ANY
+			}],
+			tokenOut: UND,
+			amountOut: M7_DD
+		},
+		{
+			type: "decreaseDebt",
+			amount: M7_DD
+		},
+		m7PhantomQuotaResetOp()
+	]
+};
+/**
+* Props for a matrix decrease-leverage tail: the account as the delayed
+* deleverage to 3x left it — 6A of position and 4A of phantom — plus the
+* matured claim.
+*/
+function buildMatrixDecreaseTailProps(c) {
+	const creditAccount = {
+		creditAccount: CREDIT_ACCOUNT,
+		creditManager: CREDIT_MANAGER,
+		creditFacade: CREDIT_FACADE,
+		underlying: UND,
+		enabledTokensMask: 0n,
+		totalDebtUSD: 0n,
+		accountDebt: M7_DEBT,
+		tokens: [{
+			token: POS,
+			balance: M7_POS_LEFT,
+			quota: m7QuotaOf(M7_POS_LEFT),
+			mask: 0n,
+			success: true
+		}, {
+			token: M7_PHANTOM,
+			balance: M7_DD,
+			quota: m7QuotaOf(M7_DD),
+			mask: 0n,
+			success: true
+		}]
+	};
+	const intent = { type: "DECREASE_LEVERAGE" };
+	const claimable = {
+		token: POS,
+		withdrawalPhantomToken: M7_PHANTOM,
+		withdrawalTokenSpent: M7_DD,
+		outputs: [{
+			token: c.claimedToken,
+			amount: c.claimedAmount,
+			isDelayed: false
+		}],
+		claimCalls: [MOCK_CLAIM_CALL]
+	};
+	return {
+		intent,
+		creditAccount,
+		sdk: buildMarketSdk({}),
+		quotaReserve: void 0,
+		claimable,
+		slippage: void 0
+	};
+}
+//#endregion
+export { ANY, DECREASE_AMOUNT_S, DECREASE_POST_D, DECREASE_POST_T, DECREASE_PRE_D, DECREASE_PRE_T, DECREASE_REPAY, M7_CLAIM_ANY, M7_DD, M7_DEBT, M7_PHANTOM, M7_POS_LEFT, PHANTOM, RWA_ASSET, UND, buildDecreaseClaimable, buildDecreaseOnchainTailProps, buildDecreaseSdk, buildDecreaseTailProps, buildMatrixDecreaseTailProps, case_matrix_7_2_tail, case_matrix_7_3_tail };

package/dist/esm/sdk/accounts/intents/tests/finish-withdraw.fixtures.js

@@ -0,0 +1,355 @@
+import { MIN_INT96 } from "../../../constants/math.js";
+import { toBN } from "../../../utils/formatter.js";
+import "../../../index.js";
+import { MOCK_CLAIM_CALL } from "../testing/sdk-mock.js";
+import { ANY, CREDIT_ACCOUNT, CREDIT_FACADE, CREDIT_MANAGER, POS, POS2, RWA_ASSET, UND, WALLET, buildMarketSdk } from "../testing/market.js";
+import { buildTailSdk } from "../testing/delayed.js";
+//#region src/sdk/accounts/intents/tests/finish-withdraw.fixtures.ts
+/**
+* Withdraw tail fixtures, ported from intent-calculator
+* `withdraw.flowFixtures.ts` (tail cases only).
+*/
+const WITHDRAW_UND = toBN("1000", 8);
+const WITHDRAW_ANY = toBN("2000", 18);
+const WITHDRAW_ANY2 = toBN("2000", 18);
+/** Withdraw amount in rwa.asset units (8 decimals, priced 1:1 with UND). */
+const WITHDRAW_RWA = toBN("2000", 8);
+const DEBT_DELTA = toBN("4000", 8);
+const PHANTOM = "0xb1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1";
+/** Per-token CA balance (legacy `A0_TOK` / und balance). */
+const A0 = toBN("100000", 18);
+const A0_UND = toBN("100000", 8);
+const QUOTA0 = toBN("50000", 8);
+/** Starting account debt on the fixture CA. */
+const WITHDRAW_PRE_D = toBN("40000", 8);
+/**
+* Starting TVL of the fixture CA tokens (ANY + ANY2 + UND). Claim may add
+* value when the phantom is absent from `tokens` (current fixtures).
+*/
+const WITHDRAW_BASE_TV = 20000000000000n;
+const WITHDRAW_TO = "0x1234567890123456789012345678901234567890";
+function withdrawAmountFor(token) {
+	if (token === "0x3333333333333333333333333333333333333333") return WITHDRAW_UND;
+	if (token === "0x1111111111111111111111111111111111111111") return WITHDRAW_ANY;
+	return WITHDRAW_ANY2;
+}
+function buildWithdrawSdk(args) {
+	return buildTailSdk({ claimedToken: args.claimedToken }, {
+		extraPrices: args.extraPrices,
+		extraDecimals: args.extraDecimals,
+		rwaAssets: args.rwaAssets,
+		phantom: PHANTOM
+	});
+}
+/** The matured withdrawal these fixtures claim. */
+function buildWithdrawClaimable(args) {
+	return {
+		token: args.claimedToken,
+		withdrawalPhantomToken: PHANTOM,
+		withdrawalTokenSpent: args.claimedAmount,
+		outputs: [{
+			token: args.claimedToken,
+			amount: args.claimedAmount,
+			isDelayed: false
+		}],
+		claimCalls: [MOCK_CLAIM_CALL]
+	};
+}
+function buildWithdrawFinishProps(args) {
+	const creditAccount = {
+		creditAccount: CREDIT_ACCOUNT,
+		creditManager: CREDIT_MANAGER,
+		creditFacade: CREDIT_FACADE,
+		underlying: UND,
+		enabledTokensMask: 0n,
+		totalDebtUSD: 0n,
+		accountDebt: WITHDRAW_PRE_D,
+		tokens: args.tokens ?? [
+			{
+				token: "0x1111111111111111111111111111111111111111",
+				balance: A0,
+				quota: QUOTA0,
+				mask: 0n,
+				success: true
+			},
+			{
+				token: "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+				balance: A0,
+				quota: QUOTA0,
+				mask: 0n,
+				success: true
+			},
+			{
+				token: "0x3333333333333333333333333333333333333333",
+				balance: A0_UND,
+				quota: 0n,
+				mask: 0n,
+				success: true
+			}
+		]
+	};
+	return {
+		intent: {
+			type: "WITHDRAW_COLLATERAL",
+			to: WITHDRAW_TO,
+			sourceToken: args.sourceToken,
+			withdrawToken: args.withdrawToken,
+			withdrawAmount: args.withdrawAmount ?? withdrawAmountFor(args.withdrawToken),
+			debtRepaid: args.debtRepaid
+		},
+		creditAccount,
+		sdk: args.sdk,
+		quotaReserve: void 0,
+		claimable: buildWithdrawClaimable(args),
+		slippage: args.slippage ?? 50
+	};
+}
+const M4_LT = 9200n;
+/** Quota the matrix cases give a balance: balance * LT / PERCENTAGE_FACTOR. */
+const m4QuotaOf = (balance) => balance * M4_LT / 10000n;
+/** Matrix baseline debt: 8U. */
+const M4_DEBT = 800000000n;
+/** Matrix payout W: 1U. */
+const M4_W = 100000000n;
+/** Proportional repayment `dD = D0 * W / C0` = 4U. */
+const M4_DD = 400000000n;
+/** Payout plus repayment: 5U redeemed by the leading half. */
+const M4_SPEND = 500000000n;
+/** Quotable withdrawal phantom: `POS2`, 1:1 with `POS`. */
+const M4_PHANTOM = POS2;
+/** 5U claimed in `ANY` (priced 1 against `UND` priced 2): 10 ANY. */
+const M4_CLAIM_ANY = 10000000000000000000n;
+/** TVL the 4.4/4.6 tails report — the echo router credits its raw input. */
+const M4_ECHO_TVL = 10000000000000000000n;
+/** The claim op every matrix tail starts with. */
+function m4ClaimOp(claimedToken, claimedAmount) {
+	return {
+		type: "claimDelayedWithdrawal",
+		token: POS,
+		withdrawalPhantomToken: M4_PHANTOM,
+		withdrawalTokenSpent: M4_SPEND,
+		outputs: [{
+			token: claimedToken,
+			amount: claimedAmount,
+			isDelayed: false
+		}]
+	};
+}
+/**
+* Quota op every matrix tail ends with: the phantom is fully spent, so its
+* quota is reset (the `MIN_INT96` sentinel encodes "reset" in quota deltas).
+*/
+function m4PhantomQuotaResetOp() {
+	return {
+		type: "changeQuota",
+		quotaIncrease: [],
+		quotaDecrease: [{
+			token: M4_PHANTOM,
+			balance: MIN_INT96
+		}],
+		desiredQuota: {}
+	};
+}
+/**
+* Matrix 4.3 tail — the claim pays `UND` directly.
+*
+* MATRIX MISMATCH: the matrix pays out first — `claim →
+* withdrawCollateral(min(W, claim.amount)) → decreaseDebt(rest) →
+* changeQuota`. The engine repays before paying out (`repay(debtRepaid,
+* keep: W)` precedes the payout leg in `planFinishWithdraw`):
+* `claim → decreaseDebt(dD) → withdrawCollateral(W) → changeQuota`.
+* Amounts are identical; only the order differs.
+*/
+const case_matrix_4_3_tail = {
+	claimedToken: UND,
+	claimedAmount: M4_SPEND,
+	totalValue: M4_SPEND,
+	ops: [
+		m4ClaimOp(UND, M4_SPEND),
+		{
+			type: "decreaseDebt",
+			amount: M4_DD
+		},
+		{
+			type: "withdrawCollateral",
+			token: UND,
+			amount: M4_W,
+			to: WALLET
+		},
+		m4PhantomQuotaResetOp()
+	]
+};
+/**
+* Matrix 4.4 tail — the claim pays `ANY`, routed into `UND` first.
+*
+* MATRIX MISMATCH: same ordering divergence as 4.3 — the matrix expects
+* `claim → swap → withdrawCollateral → decreaseDebt → changeQuota`, the
+* engine repays first:
+* `claim → swap → decreaseDebt → withdrawCollateral → changeQuota`.
+*/
+const case_matrix_4_4_tail = {
+	claimedToken: ANY,
+	claimedAmount: M4_CLAIM_ANY,
+	totalValue: M4_ECHO_TVL,
+	ops: [
+		m4ClaimOp(ANY, M4_CLAIM_ANY),
+		{
+			type: "swap",
+			from: [{
+				token: ANY,
+				balance: M4_CLAIM_ANY
+			}],
+			tokenOut: UND,
+			amountOut: M4_CLAIM_ANY
+		},
+		{
+			type: "decreaseDebt",
+			amount: M4_DD
+		},
+		{
+			type: "withdrawCollateral",
+			token: UND,
+			amount: M4_W,
+			to: WALLET
+		},
+		m4PhantomQuotaResetOp()
+	]
+};
+/**
+* Matrix 4.5 tail — 4.3 on the RWA market: unwrap before the payout.
+*
+* MATRIX MISMATCH: same ordering divergence as 4.3 — the matrix expects
+* `claim → unwrapRwaCollateral → withdrawCollateral(RWA) → decreaseDebt →
+* changeQuota`, the engine repays first:
+* `claim → decreaseDebt → unwrapRwaCollateral → withdrawCollateral(RWA) →
+* changeQuota`.
+*/
+const case_matrix_4_5_tail = {
+	claimedToken: UND,
+	claimedAmount: M4_SPEND,
+	totalValue: M4_SPEND,
+	ops: [
+		m4ClaimOp(UND, M4_SPEND),
+		{
+			type: "decreaseDebt",
+			amount: M4_DD
+		},
+		{
+			type: "unwrapRwaCollateral",
+			tokenIn: UND,
+			amount: M4_W,
+			tokenOut: RWA_ASSET,
+			amountOut: M4_W
+		},
+		{
+			type: "withdrawCollateral",
+			token: RWA_ASSET,
+			amount: M4_W,
+			to: WALLET
+		},
+		m4PhantomQuotaResetOp()
+	],
+	rwaAssets: { [UND]: RWA_ASSET }
+};
+/**
+* Matrix 4.6 tail — 4.4 on the RWA market.
+*
+* MATRIX MISMATCH: same ordering divergence as 4.3 — the matrix expects
+* `claim → swap → unwrapRwaCollateral → withdrawCollateral(RWA) →
+* decreaseDebt → changeQuota`, the engine repays first:
+* `claim → swap → decreaseDebt → unwrapRwaCollateral →
+* withdrawCollateral(RWA) → changeQuota`.
+*/
+const case_matrix_4_6_tail = {
+	claimedToken: ANY,
+	claimedAmount: M4_CLAIM_ANY,
+	totalValue: M4_ECHO_TVL,
+	ops: [
+		m4ClaimOp(ANY, M4_CLAIM_ANY),
+		{
+			type: "swap",
+			from: [{
+				token: ANY,
+				balance: M4_CLAIM_ANY
+			}],
+			tokenOut: UND,
+			amountOut: M4_CLAIM_ANY
+		},
+		{
+			type: "decreaseDebt",
+			amount: M4_DD
+		},
+		{
+			type: "unwrapRwaCollateral",
+			tokenIn: UND,
+			amount: M4_W,
+			tokenOut: RWA_ASSET,
+			amountOut: M4_W
+		},
+		{
+			type: "withdrawCollateral",
+			token: RWA_ASSET,
+			amount: M4_W,
+			to: WALLET
+		},
+		m4PhantomQuotaResetOp()
+	],
+	rwaAssets: { [UND]: RWA_ASSET }
+};
+/**
+* Props for a matrix withdraw tail: the account as the 4.3 start left it —
+* 5A of position and 5A of phantom — plus the matured claim.
+*/
+function buildMatrixWithdrawTailProps(c) {
+	const creditAccount = {
+		creditAccount: CREDIT_ACCOUNT,
+		creditManager: CREDIT_MANAGER,
+		creditFacade: CREDIT_FACADE,
+		underlying: UND,
+		enabledTokensMask: 0n,
+		totalDebtUSD: 0n,
+		accountDebt: M4_DEBT,
+		tokens: [{
+			token: POS,
+			balance: M4_SPEND,
+			quota: m4QuotaOf(M4_SPEND),
+			mask: 0n,
+			success: true
+		}, {
+			token: M4_PHANTOM,
+			balance: M4_SPEND,
+			quota: m4QuotaOf(M4_SPEND),
+			mask: 0n,
+			success: true
+		}]
+	};
+	const intent = {
+		type: "WITHDRAW_COLLATERAL",
+		to: WALLET,
+		sourceToken: POS,
+		withdrawToken: UND,
+		withdrawAmount: M4_W,
+		debtRepaid: M4_DD
+	};
+	const claimable = {
+		token: POS,
+		withdrawalPhantomToken: M4_PHANTOM,
+		withdrawalTokenSpent: M4_SPEND,
+		outputs: [{
+			token: c.claimedToken,
+			amount: c.claimedAmount,
+			isDelayed: false
+		}],
+		claimCalls: [MOCK_CLAIM_CALL]
+	};
+	return {
+		intent,
+		creditAccount,
+		sdk: buildMarketSdk({ rwaAssets: c.rwaAssets }),
+		quotaReserve: void 0,
+		claimable,
+		slippage: void 0
+	};
+}
+//#endregion
+export { A0, A0_UND, DEBT_DELTA, M4_CLAIM_ANY, M4_DD, M4_DEBT, M4_ECHO_TVL, M4_PHANTOM, M4_SPEND, M4_W, PHANTOM, QUOTA0, WITHDRAW_ANY, WITHDRAW_ANY2, WITHDRAW_BASE_TV, WITHDRAW_PRE_D, WITHDRAW_RWA, WITHDRAW_TO, WITHDRAW_UND, buildMatrixWithdrawTailProps, buildWithdrawClaimable, buildWithdrawFinishProps, buildWithdrawSdk, case_matrix_4_3_tail, case_matrix_4_4_tail, case_matrix_4_5_tail, case_matrix_4_6_tail, withdrawAmountFor };

package/dist/esm/sdk/accounts/intents/tests/open-strategy.fixtures.js

@@ -0,0 +1,119 @@
+import { toBN } from "../../../utils/formatter.js";
+import "../../../index.js";
+import { ANY, CREDIT_MANAGER, POS, UND, buildMarketSdk, valueInUnd } from "../testing/market.js";
+//#region src/sdk/accounts/intents/tests/open-strategy.fixtures.ts
+/**
+* Open-strategy fixtures.
+*
+* `POS` is the target throughout: it is 1:1 with `UND`, so the mock router's
+* oracle-priced output stays readable while the `ANY` leg (18 decimals, half the
+* price) still exercises the rescaling.
+*/
+const LT = 9200n;
+/** Quota bought for a projected balance: value in UND scaled by its LT. */
+function quotaFor(amount, token) {
+	return valueInUnd(amount, token) * LT / 10000n;
+}
+/** 1000 UND of margin. */
+const MARGIN_UND = toBN("1000", 8);
+/** 500 UND. */
+const HALF_UND = toBN("500", 8);
+/** 1000 ANY = 500 UND at fixture prices. */
+const COLLATERAL_ANY = toBN("1000", 18);
+/** ANY balance to keep unswapped: 400 ANY = 200 UND. */
+const KEEP_ANY = toBN("400", 18);
+const LEVERAGE_1X = 100n;
+const LEVERAGE_2X = 200n;
+const LEVERAGE_3X = 300n;
+/** Plain 3x on underlying margin: everything routes into the position token. */
+const case_underlying_3x = {
+	collateral: [{
+		token: UND,
+		balance: MARGIN_UND
+	}],
+	targetToken: POS,
+	leverage: LEVERAGE_3X,
+	expectedCollateral: MARGIN_UND,
+	expectedDebt: MARGIN_UND * 2n,
+	expectedAssets: [{
+		token: POS,
+		balance: MARGIN_UND * 3n
+	}],
+	expectedRouterBalances: [{
+		token: UND,
+		balance: MARGIN_UND * 3n
+	}]
+};
+/** 1x — no loan at all, just a spot conversion of the margin. */
+const case_underlying_1x = {
+	collateral: [{
+		token: UND,
+		balance: MARGIN_UND
+	}],
+	targetToken: POS,
+	leverage: LEVERAGE_1X,
+	expectedCollateral: MARGIN_UND,
+	expectedDebt: 0n,
+	expectedAssets: [{
+		token: POS,
+		balance: MARGIN_UND
+	}],
+	expectedRouterBalances: [{
+		token: UND,
+		balance: MARGIN_UND
+	}]
+};
+/**
+* Mixed margin with a leftover: 500 UND + 1000 ANY (= 500 UND) at 2x.
+*
+* 400 ANY stays put, so only 600 ANY (= 300 UND) plus the whole 1500 UND is
+* routed, and the kept ANY needs a quota of its own.
+*/
+const case_mixed_with_leftover = {
+	collateral: [{
+		token: UND,
+		balance: HALF_UND
+	}, {
+		token: ANY,
+		balance: COLLATERAL_ANY
+	}],
+	targetToken: POS,
+	leverage: LEVERAGE_2X,
+	leftoverBalances: [{
+		token: ANY,
+		balance: KEEP_ANY
+	}],
+	expectedCollateral: MARGIN_UND,
+	expectedDebt: MARGIN_UND,
+	expectedAssets: [{
+		token: ANY,
+		balance: KEEP_ANY
+	}, {
+		token: POS,
+		balance: HALF_UND + MARGIN_UND + valueInUnd(COLLATERAL_ANY - KEEP_ANY, ANY)
+	}],
+	expectedRouterBalances: [{
+		token: UND,
+		balance: HALF_UND + MARGIN_UND
+	}, {
+		token: ANY,
+		balance: COLLATERAL_ANY
+	}]
+};
+function buildOpenStrategySdk(extras) {
+	return buildMarketSdk(extras);
+}
+function buildOpenStrategyProps(c, sdk) {
+	return {
+		sdk,
+		creditManager: CREDIT_MANAGER,
+		collateral: c.collateral,
+		targetToken: c.targetToken,
+		leverage: c.leverage,
+		leftoverBalances: c.leftoverBalances,
+		slippage: void 0,
+		quotaReserve: void 0
+	};
+}
+//#endregion
+export { COLLATERAL_ANY, HALF_UND, KEEP_ANY, LEVERAGE_1X, LEVERAGE_2X, LEVERAGE_3X, LT, MARGIN_UND, buildOpenStrategyProps, buildOpenStrategySdk, case_mixed_with_leftover, case_underlying_1x, case_underlying_3x, quotaFor };