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

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 };

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

@@ -0,0 +1,117 @@
+import { ANY, RWA_ASSET, UND, WALLET, buildFixtureCreditAccount, buildMarketSdk, caToken, valueInUnd } from "../testing/market.js";
+//#region src/sdk/accounts/intents/tests/withdraw-asset.fixtures.ts
+/**
+* Start withdraw-asset fixtures (intent 4), covering the cases from the spec's
+* "withdraw collateral intent" section.
+*
+* Debt never moves, so every case is `withdrawCollateral` plus the quota
+* decrease implied by the smaller balance. The one branch is the RWA market
+* forced unwrap when the withdrawn token is the wrapped underlying.
+*/
+const LT_ANY = 9200n;
+/** 2000 ANY = 1000 UND at fixture prices. */
+const HELD_ANY = 2000000000000000000000n;
+/** 1000 UND. */
+const HELD_UND = 100000000000n;
+const DEBT = 50000000000n;
+/** Half the ANY position. */
+const OUT_ANY = 1000000000000000000000n;
+/**
+* 300 of the 1000 UND held. Not half: the underlying is weighted at 98% in this
+* fixture, so leaving 500 against 500 of debt would end below water and the
+* facade would refuse the withdrawal.
+*/
+const OUT_UND = 30000000000n;
+const QUOTA_ANY_BEFORE = valueInUnd(HELD_ANY, ANY) * LT_ANY / 10000n;
+const QUOTA_ANY_AFTER = valueInUnd(HELD_ANY - OUT_ANY, ANY) * LT_ANY / 10000n;
+/** Quota ops carry signed deltas, so a release is negative. */
+const QUOTA_ANY_DELTA = QUOTA_ANY_AFTER - QUOTA_ANY_BEFORE;
+/** Quota token out: withdraw, then release the freed quota. */
+const case_any_token = {
+	intent: {
+		type: "WITHDRAW_ASSET",
+		token: ANY,
+		amount: OUT_ANY,
+		to: WALLET
+	},
+	tokens: [caToken(UND, HELD_UND), caToken(ANY, HELD_ANY, QUOTA_ANY_BEFORE)],
+	accountDebt: DEBT,
+	totalValue: HELD_UND + valueInUnd(HELD_ANY - OUT_ANY, ANY),
+	ops: [{
+		type: "withdrawCollateral",
+		token: ANY,
+		amount: OUT_ANY,
+		to: WALLET
+	}, {
+		type: "changeQuota",
+		quotaIncrease: [],
+		quotaDecrease: [{
+			token: ANY,
+			balance: QUOTA_ANY_DELTA
+		}],
+		desiredQuota: {}
+	}]
+};
+/** Underlying out on a plain market: no quota, no unwrap. */
+const case_underlying = {
+	intent: {
+		type: "WITHDRAW_ASSET",
+		token: UND,
+		amount: OUT_UND,
+		to: WALLET
+	},
+	tokens: [caToken(UND, HELD_UND)],
+	accountDebt: DEBT,
+	totalValue: HELD_UND - OUT_UND,
+	ops: [{
+		type: "withdrawCollateral",
+		token: UND,
+		amount: OUT_UND,
+		to: WALLET
+	}]
+};
+/**
+* Underlying out on an RWA market: the wrapper cannot leave the account, so it
+* is force-unwrapped and the rwa asset is withdrawn instead.
+*/
+const case_rwa_underlying = {
+	intent: {
+		type: "WITHDRAW_ASSET",
+		token: UND,
+		amount: OUT_UND,
+		to: WALLET
+	},
+	tokens: [caToken(UND, HELD_UND)],
+	accountDebt: DEBT,
+	totalValue: HELD_UND - OUT_UND,
+	ops: [{
+		type: "unwrapRwaCollateral",
+		tokenIn: UND,
+		amount: OUT_UND,
+		tokenOut: RWA_ASSET,
+		amountOut: OUT_UND
+	}, {
+		type: "withdrawCollateral",
+		token: RWA_ASSET,
+		amount: OUT_UND,
+		to: WALLET
+	}],
+	rwaAssets: { [UND]: RWA_ASSET }
+};
+function buildWithdrawAssetSdk(c) {
+	return buildMarketSdk({ rwaAssets: c.rwaAssets });
+}
+function buildWithdrawAssetProps(c, sdk) {
+	return {
+		intent: c.intent,
+		creditAccount: buildFixtureCreditAccount({
+			accountDebt: c.accountDebt,
+			tokens: c.tokens
+		}),
+		sdk,
+		quotaReserve: void 0,
+		slippage: void 0
+	};
+}
+//#endregion
+export { DEBT, HELD_ANY, HELD_UND, LT_ANY, OUT_ANY, OUT_UND, QUOTA_ANY_AFTER, QUOTA_ANY_BEFORE, QUOTA_ANY_DELTA, buildWithdrawAssetProps, buildWithdrawAssetSdk, case_any_token, case_rwa_underlying, case_underlying };