@gearbox-protocol/sdk 16.0.0-next.2 → 16.0.0-next.21

package/dist/esm/onchain/accounts/intents/operations.js

@@ -0,0 +1,153 @@
+import { MAX_UINT256 } from "../../constants/math.js";
+//#region src/onchain/accounts/intents/operations.ts
+function buildAddCollateralOperation(input) {
+	return {
+		type: "addCollateral",
+		token: input.token,
+		amount: input.amount,
+		value: input.value,
+		calls: input.sdk.accounts.prepareAddCollateral(input.creditAccount.creditFacade, [{
+			token: input.token,
+			balance: input.amount
+		}], {})
+	};
+}
+function buildIncreaseDebtOperation(input) {
+	return {
+		type: "increaseDebt",
+		amount: input.amount,
+		calls: [input.sdk.accounts.prepareIncreaseDebt(input.creditAccount.creditFacade, input.amount)]
+	};
+}
+function buildDecreaseDebtOperation(input) {
+	return {
+		type: "decreaseDebt",
+		amount: input.amount,
+		...input.full ? { full: true } : {},
+		calls: [input.sdk.accounts.prepareChangeDebt(input.creditAccount.creditFacade, input.full ? MAX_UINT256 : input.amount, true)]
+	};
+}
+function buildWithdrawCollateralOperation(input) {
+	return {
+		type: "withdrawCollateral",
+		token: input.token,
+		amount: input.amount,
+		to: input.to,
+		...input.all ? { all: true } : {},
+		calls: [input.sdk.accounts.prepareWithdrawToken(input.creditAccount.creditFacade, input.token, input.all ? MAX_UINT256 : input.amount, input.to)]
+	};
+}
+/** One routed leg, with the amounts it was quoted at. */
+function buildSwapOperation(input) {
+	return buildCloseSwapOperation({
+		from: [{
+			token: input.tokenIn,
+			balance: input.amountIn
+		}],
+		tokenOut: input.tokenOut,
+		amountOut: input.amountOut,
+		calls: input.calls
+	});
+}
+/**
+* The many-to-one leg an exit routes: every balance listed goes in, and the
+* underlying comes out.
+*/
+function buildCloseSwapOperation(input) {
+	if (input.calls.length === 0) throw new Error("swap: missing router calls");
+	return {
+		type: "swap",
+		from: input.from,
+		tokenOut: input.tokenOut,
+		amountOut: input.amountOut,
+		calls: input.calls
+	};
+}
+function buildQuotaUpdateOperation(input) {
+	const { update, creditAccount, sdk } = input;
+	const quotaAssets = [...update.quotaIncrease, ...update.quotaDecrease];
+	const calls = quotaAssets.length === 0 ? [] : sdk.accounts.prepareUpdateQuotas(creditAccount.creditFacade, {
+		averageQuota: quotaAssets,
+		minQuota: quotaAssets
+	});
+	return {
+		type: "changeQuota",
+		desiredQuota: update.desiredQuota,
+		quotaIncrease: update.quotaIncrease,
+		quotaDecrease: update.quotaDecrease,
+		calls
+	};
+}
+/** Wraps an RWA asset into the market underlying. */
+async function buildWrapRwaCollateralOperation(input) {
+	const calls = await input.sdk.accounts.assembleRWAWrapCalls(input.amountIn, input.creditAccount.creditManager);
+	if (!calls) throw new Error("wrapRwaCollateral: no wrap calls found");
+	return {
+		type: "wrapRwaCollateral",
+		tokenIn: input.tokenIn,
+		amount: input.amountIn,
+		tokenOut: input.tokenOut,
+		amountOut: input.amountOut,
+		calls
+	};
+}
+/** Unwraps the market underlying back into its RWA asset. */
+async function buildUnwrapRwaCollateralOperation(input) {
+	const calls = await input.sdk.accounts.assembleRWAUnwrapCalls(input.amountIn, input.creditAccount.creditManager);
+	if (!calls) throw new Error("unwrapRwaCollateral: no unwrap calls found");
+	return {
+		type: "unwrapRwaCollateral",
+		tokenIn: input.tokenIn,
+		amount: input.amountIn,
+		tokenOut: input.tokenOut,
+		amountOut: input.amountOut,
+		calls
+	};
+}
+function buildStartDelayedWithdrawalOperation(input) {
+	const { preview } = input;
+	return {
+		type: "startDelayedWithdrawal",
+		token: preview.token,
+		amountIn: preview.amountIn,
+		outputs: [...preview.outputs],
+		settlement: preview.outputs.some((o) => o.isDelayed) ? "delayed" : "instant",
+		calls: input.sdk.accounts.assembleStartDelayedWithdrawalCalls({
+			creditFacade: input.creditAccount.creditFacade,
+			preview
+		})
+	};
+}
+function buildClaimDelayedWithdrawalOperation(input) {
+	const { claimable } = input;
+	return {
+		type: "claimDelayedWithdrawal",
+		token: claimable.token.toLowerCase(),
+		withdrawalPhantomToken: claimable.withdrawalPhantomToken.toLowerCase(),
+		withdrawalTokenSpent: claimable.withdrawalTokenSpent,
+		outputs: claimable.outputs.map((o) => ({
+			...o,
+			token: o.token.toLowerCase()
+		})),
+		calls: input.sdk.accounts.assembleClaimDelayedCalls({
+			creditFacade: input.creditAccount.creditFacade,
+			claimableNow: claimable
+		})
+	};
+}
+/**
+* What a request or a claim puts on the account right away, as opposed to what
+* only the phantom token represents.
+*/
+function instantOutput(outputs, token) {
+	for (const out of outputs) {
+		if (out.isDelayed || out.amount <= 0n) continue;
+		if (token != null && out.token.toLowerCase() !== token.toLowerCase()) continue;
+		return {
+			token: out.token,
+			amount: out.amount
+		};
+	}
+}
+//#endregion
+export { buildAddCollateralOperation, buildClaimDelayedWithdrawalOperation, buildCloseSwapOperation, buildDecreaseDebtOperation, buildIncreaseDebtOperation, buildQuotaUpdateOperation, buildStartDelayedWithdrawalOperation, buildSwapOperation, buildUnwrapRwaCollateralOperation, buildWithdrawCollateralOperation, buildWrapRwaCollateralOperation, instantOutput };

package/dist/esm/onchain/accounts/intents/plan.js

@@ -0,0 +1,406 @@
+import { MAX_UINT256, PERCENTAGE_FACTOR } from "../../constants/math.js";
+import "../../constants/index.js";
+import { IntentPreviewError } from "../../validation/refusal.js";
+import { toToken, toTokenAmount } from "../../validation/token.js";
+import { eq } from "./utils/common.js";
+import { assertDebtInBand, assertLeverageAtLeastOne, debtForLeverage, proportionalDebt } from "./math.js";
+//#region src/onchain/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 && eq(T, U)) throw new IntentPreviewError("insufficientSourceBalance", {
+		required: toTokenAmount(view.sdk, U, -delta),
+		held: toTokenAmount(view.sdk, U, view.balanceOf(U))
+	}, `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 (!eq(intent.token, U) && !(view.rwaAsset && eq(intent.token, view.rwaAsset))) throw new IntentPreviewError("unsupportedCollateralToken", { token: toToken(view.sdk, intent.token) }, `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 ? proportionalDebt(view, aU) : debtForLeverage(view.collateral + aU, intent.targetLeverage) - view.debt;
+	if (debtDelta < 0n) throw new IntentPreviewError("leverageOutOfRange", void 0, `deposit: target leverage ${intent.targetLeverage} would require repaying debt`);
+	assertDebtInBand(view.sdk, view.debt + debtDelta, view.band, U);
+	const T = intent.positionToken ?? positionToken(view, "deposit");
+	const depositStays = 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 = eq(intent.token, U);
+	if (!fundsInU && !(view.rwaAsset && eq(intent.token, view.rwaAsset))) throw new IntentPreviewError("unsupportedCollateralToken", { token: toToken(view.sdk, intent.token) }, `repay: only ${U}${view.rwaAsset ? ` or ${view.rwaAsset}` : ""} can be repaid with, got ${intent.token}`);
+	if (view.debt <= 0n) throw new IntentPreviewError("debtOutOfRange", {
+		requested: toTokenAmount(view.sdk, U, view.debt),
+		minDebt: toTokenAmount(view.sdk, U, view.band.minDebt),
+		maxDebt: toTokenAmount(view.sdk, U, view.band.maxDebt)
+	}, "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);
+	assertDebtInBand(view.sdk, view.debt - repaid, view.band, view.underlying);
+	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 (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 IntentPreviewError("insufficientSourceBalance", void 0, `withdraw: account holds no ${S} to redeem`);
+		return [{
+			kind: "request",
+			token: S,
+			amount: held,
+			reserve: 0n,
+			record: {
+				type: "CLOSE_ACCOUNT",
+				to: intent.to
+			}
+		}];
+	}
+	if (!eq(T, U) && !(view.rwaAsset && eq(T, view.rwaAsset))) throw new IntentPreviewError("noDelayedRoute", { token: toToken(view.sdk, T) }, `withdraw: a delayed route cannot pay out in ${T}`);
+	const payoutIsSource = 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 IntentPreviewError("noDelayedRoute", void 0, "adjustLeverage: only deleveraging can settle with a delay");
+	const shortfall = -delta - view.balanceOf(U);
+	if (shortfall <= 0n) throw new IntentPreviewError("noDelayedRoute", void 0, "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 (!eq(T, U) && !(view.rwaAsset && eq(T, view.rwaAsset))) throw new IntentPreviewError("noDelayedRoute", { token: toToken(view.sdk, T) }, `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 (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 (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 && 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 IntentPreviewError("insufficientSourceBalance", void 0, `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 = proportionalDebt(view, WU);
+	assertDebtInBand(view.sdk, view.debt - dD, view.band, view.underlying);
+	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) {
+	assertLeverageAtLeastOne(intent.targetLeverage);
+	if (view.collateral <= 0n) throw new IntentPreviewError("insufficientSourceBalance", void 0, "adjustLeverage: account has no collateral to lever");
+	const target = debtForLeverage(view.collateral, intent.targetLeverage);
+	assertDebtInBand(view.sdk, target, view.band, view.underlying);
+	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 / PERCENTAGE_FACTOR;
+/** The amount that asks for all of it, whatever "all" turns out to be. */
+const everything = (amount) => amount >= 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 && 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 IntentPreviewError("insufficientSourceBalance", void 0, `${flow}: no position token on the account`);
+	return pick;
+}
+function sourceToken(view) {
+	const pick = view.fattest();
+	if (!pick) throw new IntentPreviewError("insufficientSourceBalance", void 0, "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 IntentPreviewError("insufficientSourceBalance", void 0, `withdraw: nothing to withdraw, net value is ${view.collateral}`);
+}
+function assertPositive(amount, flow) {
+	if (amount <= 0n) throw new IntentPreviewError("insufficientSourceBalance", void 0, `${flow}: amount must be positive`);
+}
+//#endregion
+export { RAISED, planAddCollateral, planAdjustLeverage, planAdjustLeverageDelayed, planDeposit, planFinishClaimOnly, planFinishCloseAccount, planFinishDecreaseLeverage, planFinishWithdraw, planRepay, planWithdraw, planWithdrawAsset, planWithdrawDelayed };