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

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

@@ -0,0 +1,411 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_constants_math = require("../../constants/math.js");
+require("../../constants/index.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_math = require("./math.js");
+//#region src/sdk/accounts/intents/plan.ts
+/** Whatever the previous convert produced. */
+const RAISED = { raised: true };
+/** Intent 5: the token lands as is; debt is untouched. */
+function planAddCollateral(intent) {
+	assertPositive(intent.amount, "addCollateral");
+	return [add(intent.token, intent.amount, intent.value)];
+}
+/** Intent 4: one asset out at fixed debt. */
+function planWithdrawAsset(intent, view) {
+	assertPositive(intent.amount, "withdrawAsset");
+	return payout(view, intent.token, intent.amount, intent.to);
+}
+/** Intent 6: collateral fixed, debt retargeted to `C0 · (L1 − 1)`. */
+function planAdjustLeverage(intent, view) {
+	const { U, delta } = leverageShape(intent, view);
+	if (delta === 0n) return [];
+	const T = intent.token ?? positionToken(view, "adjustLeverage");
+	if (delta > 0n) return [borrow(delta), convert(U, T, delta)];
+	const shortfall = -delta - view.balanceOf(U);
+	if (shortfall > 0n && require_sdk_accounts_intents_utils_common.eq(T, U)) throw new require_sdk_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", `adjustLeverage: needs ${-delta} underlying, account holds ${view.balanceOf(U)}`);
+	return [...shortfall > 0n ? [convert(T, U, view.price(U, T, shortfall))] : [], repay(-delta)];
+}
+/** Intents 1.1 / 1.2: collateral grows by `a`, debt grows to match. */
+function planDeposit(intent, view) {
+	assertPositive(intent.amount, "deposit");
+	const U = view.underlying;
+	if (!require_sdk_accounts_intents_utils_common.eq(intent.token, U) && !(view.rwaAsset && require_sdk_accounts_intents_utils_common.eq(intent.token, view.rwaAsset))) throw new require_sdk_accounts_intents_types.IntentPreviewError("unsupportedCollateralToken", `deposit: only ${U}${view.rwaAsset ? ` or ${view.rwaAsset}` : ""} can be deposited, got ${intent.token}`);
+	const aU = view.price(intent.token, U, intent.amount);
+	const debtDelta = intent.targetLeverage === void 0 ? require_sdk_accounts_intents_math.proportionalDebt(view, aU) : require_sdk_accounts_intents_math.debtForLeverage(view.collateral + aU, intent.targetLeverage) - view.debt;
+	if (debtDelta < 0n) throw new require_sdk_accounts_intents_types.IntentPreviewError("leverageOutOfRange", `deposit: target leverage ${intent.targetLeverage} would require repaying debt`);
+	require_sdk_accounts_intents_math.assertDebtInBand(view.debt + debtDelta, view.band);
+	const T = intent.positionToken ?? positionToken(view, "deposit");
+	const depositStays = require_sdk_accounts_intents_utils_common.eq(intent.token, T);
+	return [
+		add(intent.token, intent.amount, intent.value),
+		...depositStays ? [] : [convert(intent.token, U, intent.amount)],
+		...debtDelta > 0n ? [borrow(debtDelta)] : [],
+		convert(U, T, debtDelta + (depositStays ? 0n : aU))
+	].filter((s) => s.kind !== "convert" || s.amount !== 0n);
+}
+/**
+* Intent 3: funding comes in from the wallet and goes straight into the debt.
+* Collateral never moves, so the whole plan is the funding's way to `U`.
+*
+* Funding in `U` needs no way there: it lands and is repaid, which is the whole
+* plan. An RWA market also takes the raw asset behind its underlying, and that
+* one is wrapped on the way in.
+*
+* `MAX_UINT256` settles the loan: the wallet is asked for the debt as it stands
+* plus the headroom {@link SETTLE_MARGIN} allows for the interest of the blocks
+* still to come, since the facade is told to repay everything outstanding
+* rather than the amount quoted here.
+*/
+function planRepay(intent, view) {
+	assertPositive(intent.amount, "repay");
+	const U = view.underlying;
+	const fundsInU = require_sdk_accounts_intents_utils_common.eq(intent.token, U);
+	if (!fundsInU && !(view.rwaAsset && require_sdk_accounts_intents_utils_common.eq(intent.token, view.rwaAsset))) throw new require_sdk_accounts_intents_types.IntentPreviewError("unsupportedCollateralToken", `repay: only ${U}${view.rwaAsset ? ` or ${view.rwaAsset}` : ""} can be repaid with, got ${intent.token}`);
+	if (view.debt <= 0n) throw new require_sdk_accounts_intents_types.IntentPreviewError("debtOutOfRange", "repay: the account owes nothing");
+	const funding = everything(intent.amount) ? view.price(U, intent.token, withMargin(view.debt)) : intent.amount;
+	const repaid = min(view.price(intent.token, U, funding), view.debt);
+	require_sdk_accounts_intents_math.assertDebtInBand(view.debt - repaid, view.band);
+	return [
+		add(intent.token, funding, intent.value),
+		...fundsInU ? [] : [convert(intent.token, U, funding)],
+		...repaid === view.debt ? [clearQuotas()] : [],
+		repay(repaid)
+	];
+}
+/**
+* Intent 2.1: `W` of value leaves, debt shrinks by `D0 · W / C0` so leverage
+* holds. Both are funded by the source `S`.
+*/
+function planWithdraw(intent, view) {
+	const { U, T, S, WU, dD, all } = withdrawShape(intent, view);
+	if (all) return [
+		clearQuotas(),
+		{ kind: "closeAll" },
+		...view.debt > 0n ? [repay(view.debt)] : [],
+		{
+			kind: "sweep",
+			to: intent.to
+		}
+	];
+	if (require_sdk_accounts_intents_utils_common.eq(T, U)) return [
+		convert(S, U, view.price(U, S, WU + dD)),
+		repay(dD, intent.amount),
+		...payout(view, U, intent.amount, intent.to)
+	];
+	return [
+		convert(S, U, view.price(U, S, dD)),
+		repay(dD),
+		convert(S, T, view.price(U, S, WU)),
+		...payout(view, T, RAISED, intent.to)
+	];
+}
+/**
+* Intent 2.1 against a source that cannot be sold on a DEX.
+*
+* Some collateral only converts through its issuer — a Securitize dsToken, a
+* Mellow share — which answers a redemption request now and pays out days
+* later. The trade is unchanged; what changes is that the proceeds do not exist
+* yet, so this half only requests the redemption:
+*
+* ```
+* request(S, W + dD) → [days] → claim → convert → repay → withdraw
+* ```
+*
+* The tail is planned at claim time by {@link planFinishWithdraw}, from the
+* intent this request records — only then is the claimed amount, and the token
+* it arrived in, known. An exit records {@link planFinishCloseAccount}'s intent
+* instead, and rebuilds itself from the account rather than from the request.
+*/
+function planWithdrawDelayed(intent, view) {
+	const { U, T, S, WU, dD, all } = withdrawShape(intent, view);
+	if (all) {
+		const held = view.balanceOf(S);
+		if (held <= 0n) throw new require_sdk_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", `withdraw: account holds no ${S} to redeem`);
+		return [{
+			kind: "request",
+			token: S,
+			amount: held,
+			reserve: 0n,
+			record: {
+				type: "CLOSE_ACCOUNT",
+				to: intent.to
+			}
+		}];
+	}
+	if (!require_sdk_accounts_intents_utils_common.eq(T, U) && !(view.rwaAsset && require_sdk_accounts_intents_utils_common.eq(T, view.rwaAsset))) throw new require_sdk_accounts_intents_types.IntentPreviewError("noDelayedRoute", `withdraw: a delayed route cannot pay out in ${T}`);
+	const payoutIsSource = require_sdk_accounts_intents_utils_common.eq(T, S);
+	return [{
+		kind: "request",
+		token: S,
+		amount: view.price(U, S, payoutIsSource ? dD : WU + dD),
+		reserve: payoutIsSource ? intent.amount : 0n,
+		record: {
+			type: "WITHDRAW_COLLATERAL",
+			to: intent.to,
+			withdrawToken: T,
+			withdrawAmount: intent.amount,
+			sourceToken: S,
+			debtRepaid: dD
+		}
+	}];
+}
+/**
+* Intent 6.2 against a position token that only redeems through its issuer.
+*
+* Only deleveraging can be delayed: raising leverage borrows and buys, both of
+* which settle at once. The request covers whatever idle underlying does not
+* already, and the tail repays from the claim.
+*/
+function planAdjustLeverageDelayed(intent, view) {
+	const { U, delta } = leverageShape(intent, view);
+	if (delta >= 0n) throw new require_sdk_accounts_intents_types.IntentPreviewError("noDelayedRoute", "adjustLeverage: only deleveraging can settle with a delay");
+	const shortfall = -delta - view.balanceOf(U);
+	if (shortfall <= 0n) throw new require_sdk_accounts_intents_types.IntentPreviewError("noDelayedRoute", "adjustLeverage: idle underlying covers the repayment, nothing to redeem");
+	const T = intent.token ?? positionToken(view, "adjustLeverage");
+	return [{
+		kind: "request",
+		token: T,
+		amount: view.price(U, T, shortfall),
+		reserve: 0n,
+		record: { type: "DECREASE_LEVERAGE" }
+	}];
+}
+/** Everything claimed goes into the debt. */
+function planFinishDecreaseLeverage(claimable, claimed, view) {
+	return [
+		claim(claimable),
+		convert(claimed.token, view.underlying, claimed.amount),
+		repay(RAISED)
+	];
+}
+/**
+* The claim is split between the promised payout `W` and the debt the leading
+* half deferred: the payout is served first, the debt gets what is left, so a
+* routing shortfall shows as leverage a touch above target rather than as a
+* payout the wallet was promised and did not get.
+*/
+function planFinishWithdraw(intent, claimable, claimed, view) {
+	const U = view.underlying;
+	const T = intent.withdrawToken;
+	const W = intent.withdrawAmount;
+	if (!require_sdk_accounts_intents_utils_common.eq(T, U) && !(view.rwaAsset && require_sdk_accounts_intents_utils_common.eq(T, view.rwaAsset))) throw new require_sdk_accounts_intents_types.IntentPreviewError("noDelayedRoute", `finishWithdraw: cannot pay out in ${T}`);
+	if (intent.debtRepaid === 0n) return [
+		claim(claimable),
+		convert(claimed.token, T, claimed.amount),
+		...payout(view, T, {
+			raised: true,
+			max: W
+		}, intent.to)
+	];
+	if (require_sdk_accounts_intents_utils_common.eq(intent.sourceToken, T)) return [
+		claim(claimable),
+		convert(claimed.token, U, claimed.amount),
+		repay({
+			raised: true,
+			max: intent.debtRepaid
+		}),
+		...payout(view, T, W, intent.to)
+	];
+	if (require_sdk_accounts_intents_utils_common.eq(T, U)) return [
+		claim(claimable),
+		convert(claimed.token, U, claimed.amount),
+		repay(intent.debtRepaid, W),
+		...payout(view, U, {
+			raised: true,
+			max: W
+		}, intent.to)
+	];
+	const reserved = min(view.price(T, claimed.token, W), claimed.amount);
+	return [
+		claim(claimable),
+		convert(claimed.token, U, claimed.amount - reserved),
+		repay({
+			raised: true,
+			max: intent.debtRepaid
+		}),
+		convert(claimed.token, T, reserved),
+		...payout(view, T, {
+			raised: true,
+			max: W
+		}, intent.to)
+	];
+}
+/**
+* The tail of an exit: the claim lands, everything the account holds is sold
+* into the underlying, the loan is settled out of the proceeds and the rest
+* goes to the wallet. The account survives it, empty and owing nothing.
+*
+* Nothing is quoted from the request — the same shape {@link planWithdraw}
+* builds for an instant exit is rebuilt here against the account as it stands
+* now, which is the only state that can name these amounts.
+*/
+function planFinishCloseAccount(intent, claimable, claimed, view) {
+	const wrap = view.rwaAsset && require_sdk_accounts_intents_utils_common.eq(claimed.token, view.rwaAsset) ? [convert(claimed.token, view.underlying, view.balanceOf(claimed.token) + claimed.amount)] : [];
+	return [
+		claim(claimable),
+		...wrap,
+		clearQuotas(),
+		{ kind: "closeAll" },
+		...view.debt > 0n ? [repay(view.debt)] : [],
+		{
+			kind: "sweep",
+			to: intent.to
+		}
+	];
+}
+/** Nothing is owed beyond the claim: the tokens land and quotas catch up. */
+function planFinishClaimOnly(claimable) {
+	return [claim(claimable)];
+}
+/**
+* What a withdrawal comes down to: the payout `W` of `T` priced in the
+* underlying, the debt `dD` that keeps leverage flat, and the source `S` both
+* are funded from. Shared so that the instant and the delayed leading half
+* cannot disagree on the amounts.
+*/
+function withdrawShape(intent, view) {
+	assertPositive(intent.amount, "withdraw");
+	const U = view.underlying;
+	const T = intent.tokenOut ?? U;
+	const S = intent.sourceToken ?? sourceToken(view);
+	if (everything(intent.amount)) {
+		assertHasValue(view);
+		return {
+			U,
+			T,
+			S,
+			WU: view.collateral,
+			dD: view.debt,
+			all: true
+		};
+	}
+	const WU = view.price(T, U, intent.amount);
+	if (WU <= 0n) throw new require_sdk_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", `withdraw: cannot price ${intent.amount} of ${T}`);
+	if (WU >= view.collateral) {
+		assertHasValue(view);
+		return {
+			U,
+			T,
+			S,
+			WU,
+			dD: view.debt,
+			all: true
+		};
+	}
+	const dD = require_sdk_accounts_intents_math.proportionalDebt(view, WU);
+	require_sdk_accounts_intents_math.assertDebtInBand(view.debt - dD, view.band);
+	return {
+		U,
+		T,
+		S,
+		WU,
+		dD,
+		all: false
+	};
+}
+/**
+* The debt move a leverage target implies. Shared by the instant and the
+* delayed leading half; the token that funds it is resolved by the caller,
+* once it knows the move needs one at all.
+*/
+function leverageShape(intent, view) {
+	require_sdk_accounts_intents_math.assertLeverageAtLeastOne(intent.targetLeverage);
+	if (view.collateral <= 0n) throw new require_sdk_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", "adjustLeverage: account has no collateral to lever");
+	const target = require_sdk_accounts_intents_math.debtForLeverage(view.collateral, intent.targetLeverage);
+	require_sdk_accounts_intents_math.assertDebtInBand(target, view.band);
+	return {
+		U: view.underlying,
+		delta: target - view.debt
+	};
+}
+const add = (token, amount, value) => ({
+	kind: "add",
+	token,
+	amount,
+	value
+});
+const borrow = (amount) => ({
+	kind: "borrow",
+	amount
+});
+const repay = (amount, keep) => keep === void 0 ? {
+	kind: "repay",
+	amount
+} : {
+	kind: "repay",
+	amount,
+	keep
+};
+const convert = (from, to, amount) => ({
+	kind: "convert",
+	from,
+	to,
+	amount
+});
+const claim = (claimable) => ({
+	kind: "claim",
+	claimable
+});
+const clearQuotas = () => ({ kind: "clearQuotas" });
+/**
+* Headroom a settlement raises on top of the debt it read, in
+* `PERCENTAGE_FACTOR`: enough interest for the transaction to sit in the
+* mempool for hours at any sane borrow rate, small enough not to matter to the
+* wallet that fronts it.
+*/
+const SETTLE_MARGIN = 10n;
+const withMargin = (debt) => debt + debt * SETTLE_MARGIN / require_sdk_constants_math.PERCENTAGE_FACTOR;
+/** The amount that asks for all of it, whatever "all" turns out to be. */
+const everything = (amount) => amount >= require_sdk_constants_math.MAX_UINT256;
+const min = (a, b) => a < b ? a : b;
+/**
+* Hands `amount` of `token` to `to`. The wrapped underlying of an RWA market
+* cannot leave the account, so it is unwrapped into the raw asset on the way.
+*/
+function payout(view, token, amount, to) {
+	if (view.rwaAsset && require_sdk_accounts_intents_utils_common.eq(token, view.underlying)) return [convert(view.underlying, view.rwaAsset, amount), {
+		kind: "withdraw",
+		token: view.rwaAsset,
+		amount: RAISED,
+		to
+	}];
+	return [{
+		kind: "withdraw",
+		token,
+		amount,
+		to
+	}];
+}
+function positionToken(view, flow) {
+	const pick = view.fattest([view.underlying]);
+	if (!pick) throw new require_sdk_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", `${flow}: no position token on the account`);
+	return pick;
+}
+function sourceToken(view) {
+	const pick = view.fattest();
+	if (!pick) throw new require_sdk_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", "withdraw: account has no spendable balance");
+	return pick;
+}
+/** An account whose debt has eaten its collateral has nothing to hand over. */
+function assertHasValue(view) {
+	if (view.collateral <= 0n) throw new require_sdk_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", `withdraw: nothing to withdraw, net value is ${view.collateral}`);
+}
+function assertPositive(amount, flow) {
+	if (amount <= 0n) throw new require_sdk_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", `${flow}: amount must be positive`);
+}
+//#endregion
+exports.RAISED = RAISED;
+exports.planAddCollateral = planAddCollateral;
+exports.planAdjustLeverage = planAdjustLeverage;
+exports.planAdjustLeverageDelayed = planAdjustLeverageDelayed;
+exports.planDeposit = planDeposit;
+exports.planFinishClaimOnly = planFinishClaimOnly;
+exports.planFinishCloseAccount = planFinishCloseAccount;
+exports.planFinishDecreaseLeverage = planFinishDecreaseLeverage;
+exports.planFinishWithdraw = planFinishWithdraw;
+exports.planRepay = planRepay;
+exports.planWithdraw = planWithdraw;
+exports.planWithdrawAsset = planWithdrawAsset;
+exports.planWithdrawDelayed = planWithdrawDelayed;