@gearbox-protocol/sdk 16.0.0-next.9 → 16.1.0

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

@@ -1,10 +1,10 @@
-import { calcPositionLeverage } from "../../market/math.js";
-import { IntentPreviewError } from "./refusal.js";
+import { IntentPreviewError } from "../../validation/refusal.js";
+import { toToken, toTokenAmount } from "../../validation/token.js";
 import { eq, toTargetDecimals } from "./utils/common.js";
-import { convertAmount } from "./utils/convert-amount.js";
 import { isRedemptionPhantomToken } from "./utils/pick-token.js";
 import { assertCanBorrow, assertCollateralised, assertGrowthAllowed, assertQuotaHeadroom } from "./guards.js";
 import { OperationLedger } from "./utils/ledger.js";
+import { collectPriceImpact } from "./utils/price-impact.js";
 import { clearedQuotas, getQuotasForUpdate, quotasAfterUpdate } from "./utils/quotas-for-update.js";
 import { createRouterPaths } from "./utils/router-path.js";
 import { buildAddCollateralOperation, buildClaimDelayedWithdrawalOperation, buildCloseSwapOperation, buildDecreaseDebtOperation, buildIncreaseDebtOperation, buildQuotaUpdateOperation, buildStartDelayedWithdrawalOperation, buildSwapOperation, buildUnwrapRwaCollateralOperation, buildWithdrawCollateralOperation, buildWrapRwaCollateralOperation, instantOutput } from "./operations.js";
@@ -23,25 +23,47 @@ async function realize(steps, props) {
 	const { creditAccount, sdk, slippage, quotaReserve } = props;
 	const { underlying } = creditAccount;
 	const rwaAsset = sdk.tokensMeta.rwaUnderlyings.get(underlying)?.asset;
-	const price = convertAmount(sdk, creditAccount.creditManager);
 	const paths = props.paths ?? createRouterPaths({
 		sdk,
 		creditAccount,
 		slippage
 	});
 	const market = sdk.marketRegister.findByCreditManager(creditAccount.creditManager);
+	const price = (from, to, amount) => market.priceOracle.safeConvert(from, to, amount).value;
 	const suite = sdk.marketRegister.findCreditManager(creditAccount.creditManager);
-	const ledger = new OperationLedger({
+	const start = {
 		initialAssets: creditAccount.tokens,
 		underlying,
-		debt: creditAccount.accountDebt,
+		debt: creditAccount.totalDebt,
 		convert: price
-	});
+	};
+	/**
+	* The floor: every routed leg counted at the amount it guarantees. This is
+	* what the calls are built from — a repayment may only spend underlying the
+	* route promises to have raised — and what the guards are answered on, since
+	* a floor that does not clear the facade's bar is a transaction that can
+	* revert.
+	*/
+	const ledger = new OperationLedger(start);
+	/**
+	* The same walk with every routed leg counted at the amount the pathfinder
+	* expects to return. Nothing is built from it: it is where the position
+	* actually lands, so it is what the reported state is read off.
+	*/
+	const expected = new OperationLedger(start);
 	const operations = [];
-	const push = (op) => {
+	/**
+	* @param asExpected - The operation as the expected branch sees it, for the
+	* legs where the two differ. Defaults to the operation itself, which is the
+	* case for everything whose amount the calldata fixes.
+	*/
+	const push = (op, asExpected = op) => {
 		operations.push(op);
 		ledger.apply(op);
+		expected.apply(asExpected);
 	};
+	/** One per routed leg, each already awaiting its quote; folded after the guards. */
+	const probes = [];
 	/** Output of the last convert or claim, for `RAISED` amounts. */
 	let raised = 0n;
 	/** The request, before the walk's end state can be attached to it. */
@@ -60,14 +82,8 @@ async function realize(steps, props) {
 	const assertHolds = (token, amount, what) => {
 		const held = ledger.balanceOf(token);
 		if (amount <= 0n || held < amount) throw new IntentPreviewError("insufficientSourceBalance", {
-			required: {
-				token,
-				balance: amount
-			},
-			held: {
-				token,
-				balance: held
-			}
+			required: toTokenAmount(sdk, token, amount),
+			held: toTokenAmount(sdk, token, held)
 		}, `${what}: needs ${amount} of ${token}, account holds ${held}`);
 	};
 	for (const step of steps) switch (step.kind) {
@@ -81,7 +97,7 @@ async function realize(steps, props) {
 			}));
 			break;
 		case "borrow":
-			assertCanBorrow(suite, step.amount);
+			assertCanBorrow(sdk, suite, step.amount);
 			push(buildIncreaseDebtOperation({
 				amount: step.amount,
 				creditAccount,
@@ -139,28 +155,44 @@ async function realize(steps, props) {
 				amount,
 				keep: held - amount
 			});
-			push(buildSwapOperation({
+			if (leg.probe) probes.push(leg.probe);
+			const swap = buildSwapOperation({
 				tokenIn: step.from,
 				amountIn: amount,
 				tokenOut: step.to,
 				amountOut: leg.minAmount,
 				calls: leg.calls
-			}));
+			});
+			push(swap, {
+				...swap,
+				amountOut: leg.amount
+			});
 			raised = leg.minAmount;
 			break;
 		}
 		case "closeAll": {
 			const balances = ledger.snapshot().assets.filter((a) => !eq(a.token, underlying) && a.balance > DUST);
 			const pending = balances.find((a) => isRedemptionPhantomToken(sdk, a.token));
-			if (pending) throw new IntentPreviewError("withdrawalInProgress", { inFlight: pending }, `closeAll: ${pending.token} is a pending withdrawal, claim it first`);
+			if (pending) throw new IntentPreviewError("withdrawalInProgress", { inFlight: toTokenAmount(sdk, pending.token, pending.balance) }, `closeAll: ${pending.token} is a pending withdrawal, claim it first`);
 			if (balances.length > 0) {
 				const leg = await paths.closeAll({ balances });
-				if (leg.calls.length > 0 || leg.minAmount > 0n) push(buildCloseSwapOperation({
-					from: balances,
-					tokenOut: underlying,
-					amountOut: leg.minAmount,
-					calls: leg.calls
-				}));
+				if (leg.probe) probes.push(leg.probe);
+				if (leg.calls.length > 0 || leg.minAmount > 0n) {
+					const sale = buildCloseSwapOperation({
+						from: balances,
+						tokenOut: underlying,
+						amountOut: leg.minAmount,
+						calls: leg.calls
+					});
+					push(sale, {
+						...sale,
+						from: balances.map((a) => ({
+							token: a.token,
+							balance: expected.balanceOf(a.token)
+						})),
+						amountOut: leg.amount
+					});
+				}
 			}
 			raised = ledger.balanceOf(underlying);
 			break;
@@ -180,10 +212,7 @@ async function realize(steps, props) {
 		}
 		case "request": {
 			const asset = await delayedConfig(sdk, creditAccount, step.token);
-			if (ledger.balanceOf(asset.withdrawalPhantomToken) > 0n) throw new IntentPreviewError("withdrawalInProgress", { inFlight: {
-				token: asset.withdrawalPhantomToken,
-				balance: ledger.balanceOf(asset.withdrawalPhantomToken)
-			} }, `request: ${asset.withdrawalPhantomToken} already holds a pending withdrawal`);
+			if (ledger.balanceOf(asset.withdrawalPhantomToken) > 0n) throw new IntentPreviewError("withdrawalInProgress", { inFlight: toTokenAmount(sdk, asset.withdrawalPhantomToken, ledger.balanceOf(asset.withdrawalPhantomToken)) }, `request: ${asset.withdrawalPhantomToken} already holds a pending withdrawal`);
 			assertHolds(step.token, step.amount + step.reserve, "request");
 			const preview = await sdk.accounts.previewDelayedWithdrawal({
 				creditAccount: creditAccount.creditAccount,
@@ -229,24 +258,32 @@ async function realize(steps, props) {
 				creditAccount,
 				sdk
 			}));
-			for (const { token, balance } of ledger.snapshot().assets) push(buildWithdrawCollateralOperation({
-				token,
-				amount: balance,
-				to: step.to,
-				all: true,
-				creditAccount,
-				sdk
-			}));
+			for (const { token, balance } of ledger.snapshot().assets) {
+				const payout = buildWithdrawCollateralOperation({
+					token,
+					amount: balance,
+					to: step.to,
+					all: true,
+					creditAccount,
+					sdk
+				});
+				push(payout, {
+					...payout,
+					amount: expected.balanceOf(token)
+				});
+			}
 			break;
 		}
 	}
-	const { assets, totalValue, debt } = ledger.snapshot();
+	const floor = ledger.snapshot();
+	const { assets, debt } = floor;
+	const projected = expected.snapshot();
 	assertGrowthAllowed({
 		sdk,
 		suite,
 		market,
 		before: creditAccount.tokens,
-		after: assets
+		after: projected.assets
 	});
 	const quotas = cleared ?? getQuotasForUpdate({
 		assetsBefore: creditAccount.tokens,
@@ -260,7 +297,7 @@ async function realize(steps, props) {
 		convert: price
 	});
 	if (!cleared && quotas.quotaIncrease.length + quotas.quotaDecrease.length > 0) {
-		assertQuotaHeadroom(market, quotas.quotaIncrease);
+		assertQuotaHeadroom(sdk, market, quotas.quotaIncrease);
 		push(buildQuotaUpdateOperation({
 			update: quotas,
 			creditAccount,
@@ -268,28 +305,29 @@ async function realize(steps, props) {
 		}));
 	}
 	const quotasAfter = quotasAfterUpdate(creditAccount.tokens, quotas.desiredQuota);
+	const quoted = Object.values(quotasAfter);
 	const snapshot = {
 		creditManager: creditAccount.creditManager,
-		assets,
-		quotas: Object.values(quotasAfter),
+		assets: projected.assets,
+		quotas: quoted,
 		totalDebt: debt,
-		totalValue
+		totalValue: projected.totalValue
 	};
-	const projectedPool = { availableLiquidityChange: creditAccount.accountDebt - debt };
-	const metrics = {
-		healthFactor: sdk.positions.healthFactor(snapshot),
-		borrowRate: sdk.positions.borrowRate(snapshot, projectedPool),
-		timeToLiquidation: sdk.positions.timeToLiquidation(snapshot, projectedPool),
-		liquidationPrice: sdk.positions.liquidationPrice(snapshot)
-	};
-	assertCollateralised(paysOut ? sdk.positions.healthFactor(snapshot, { safePrices: true }) : metrics.healthFactor, paysOut);
+	const projection = sdk.positions.projection(snapshot, { availableLiquidityChange: creditAccount.totalDebt - debt });
+	assertCollateralised(sdk.positions.healthFactor({
+		...snapshot,
+		assets,
+		totalValue: floor.totalValue
+	}, { safePrices: paysOut }), paysOut);
+	const priceImpact = await collectPriceImpact(probes, {
+		totalValue: projected.totalValue,
+		netValue: projected.totalValue - debt,
+		toUnderlying: (from, amount) => price(from, underlying, amount)
+	});
 	const state = {
-		totalValue,
-		accountDebt: debt,
-		leverage: calcPositionLeverage(totalValue, debt),
-		assets: assets.map((a) => market.priceOracle.toTokenAmount(a.token, a.balance)),
-		quotas: quotasAfter,
-		...metrics
+		...projection,
+		priceImpact,
+		currentPrice: sdk.positions.currentPrice(snapshot)
 	};
 	return {
 		operations,
@@ -309,11 +347,11 @@ async function realize(steps, props) {
 */
 async function delayedConfig(sdk, creditAccount, token) {
 	const compressor = sdk.withdrawalCompressor;
-	if (!compressor) throw new IntentPreviewError("noDelayedRoute", { token }, "request: chain has no withdrawal compressor");
+	if (!compressor) throw new IntentPreviewError("noDelayedRoute", { token: toToken(sdk, token) }, "request: chain has no withdrawal compressor");
 	const assets = await compressor.findWithdrawableAssets(creditAccount.creditManager, token);
-	if (assets.length === 0) throw new IntentPreviewError("noDelayedRoute", { token }, `request: ${token} has no delayed withdrawal config`);
+	if (assets.length === 0) throw new IntentPreviewError("noDelayedRoute", { token: toToken(sdk, token) }, `request: ${token} has no delayed withdrawal config`);
 	if (assets.length > 1) throw new IntentPreviewError("multipleDelayedWithdrawals", {
-		token,
+		token: toToken(sdk, token),
 		venues: assets.length
 	}, `request: ${token} has ${assets.length} delayed withdrawal configs`);
 	return assets[0];

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

@@ -1,4 +1,6 @@
-import { IntentPreviewError } from "./refusal.js";
+import { IntentPreviewError } from "../../validation/refusal.js";
+import { toTokenAmount } from "../../validation/token.js";
+import { toTargetDecimals } from "./utils/common.js";
 import { createOraclePaths } from "./utils/router-path.js";
 import { planFinishClaimOnly, planFinishCloseAccount, planFinishDecreaseLeverage, planFinishWithdraw } from "./plan.js";
 import { instantOutput } from "./operations.js";
@@ -12,6 +14,10 @@ import { accountView } from "./view.js";
 * Shared by the two callers that need it and must not disagree — the tail as
 * it is previewed days later against the account that really exists, and the
 * tail as it is projected the moment the request is made.
+*
+* A claim that brought only part of what was queued is served in proportion,
+* see {@link partialTail}: the intent's payout and its repayment are cut to the
+* share that arrived, and the rest of both is handed to the next claim.
 */
 function planTail(args) {
 	const { intent, claimable, view } = args;
@@ -20,17 +26,118 @@ function planTail(args) {
 		if (!output) throw new IntentPreviewError("insufficientSourceBalance", void 0, "finishIntent: the claim credits nothing to spend");
 		return output;
 	};
+	const queued = claimable.outputs.find((o) => o.isDelayed && o.amount > 0n);
+	if (queued) return partialTail({
+		intent,
+		claimable,
+		queued,
+		view
+	});
 	switch (intent.type) {
-		case "WITHDRAW_COLLATERAL": return planFinishWithdraw(intent, claimable, claimed(), view);
-		case "DECREASE_LEVERAGE": return planFinishDecreaseLeverage(claimable, claimed(), view);
-		case "CLOSE_ACCOUNT": return planFinishCloseAccount(intent, claimable, claimed(), view);
+		case "WITHDRAW_COLLATERAL": return whole(planFinishWithdraw(intent, claimable, claimed(), view));
+		case "DECREASE_LEVERAGE": return whole(planFinishDecreaseLeverage(claimable, claimed(), view));
+		case "CLOSE_ACCOUNT": return whole(planFinishCloseAccount(intent, claimable, claimed(), view));
 		case "ADD_COLLATERAL":
 		case "INCREASE_LEVERAGE":
 		case "DEPOSIT":
-		case "DEPOSIT_AND_INCREASE_LEVERAGE": return planFinishClaimOnly(claimable);
+		case "DEPOSIT_AND_INCREASE_LEVERAGE": return whole(planFinishClaimOnly(claimable));
 		default: throw new Error(`${intent.type} - not implemented`);
 	}
 }
+const whole = (steps) => ({
+	steps,
+	remainder: void 0
+});
+/**
+* The tail of a claim that settled only part of the withdrawal it matured.
+*
+* Only a legacy Mellow multivault answers one this way — it pays out what its
+* subvaults hold liquid and queues the rest — and the engine cannot finish an
+* intent it has been given a fraction of the funds for. So the fraction is what
+* it serves: the payout and the repayment are cut in the proportion that
+* arrived, which keeps the withdrawal at the fixed leverage it was asked for
+* instead of paying the wallet out first and deleveraging a claim later, and
+* the untouched half of each is carried to the next claim by the remainder.
+*
+* Two intents cannot be served in part at all. An exit sells the account whole,
+* and it cannot while a withdrawal is in flight — the phantom is neither
+* sellable nor transferable — so a partial claim only repays what it brought
+* and the account is emptied by the claim that brings the last of it. A claim
+* that credited nothing at all leaves nothing to spend, so it is taken alone:
+* it is still worth sending, since it is what moves the queue.
+*/
+function partialTail(args) {
+	const { intent, claimable, queued, view } = args;
+	const inFlight = toTokenAmount(view.sdk, queued.token, queued.amount);
+	const claimed = instantOutput(claimable.outputs);
+	if (!claimed) return {
+		steps: planFinishClaimOnly(claimable),
+		remainder: {
+			inFlight,
+			intent
+		}
+	};
+	switch (intent.type) {
+		case "WITHDRAW_COLLATERAL": {
+			const served = arrivedShare(claimed, queued, view.sdk);
+			const withdrawAmount = part(intent.withdrawAmount, served);
+			const debtRepaid = part(intent.debtRepaid, served);
+			return {
+				steps: planFinishWithdraw({
+					...intent,
+					withdrawAmount,
+					debtRepaid
+				}, claimable, claimed, view),
+				remainder: {
+					inFlight,
+					intent: {
+						...intent,
+						withdrawAmount: intent.withdrawAmount - withdrawAmount,
+						debtRepaid: intent.debtRepaid - debtRepaid
+					}
+				}
+			};
+		}
+		case "DECREASE_LEVERAGE":
+		case "CLOSE_ACCOUNT": return {
+			steps: planFinishDecreaseLeverage(claimable, claimed, view),
+			remainder: {
+				inFlight,
+				intent
+			}
+		};
+		case "ADD_COLLATERAL":
+		case "INCREASE_LEVERAGE":
+		case "DEPOSIT":
+		case "DEPOSIT_AND_INCREASE_LEVERAGE": return {
+			steps: planFinishClaimOnly(claimable),
+			remainder: {
+				inFlight,
+				intent
+			}
+		};
+		default: throw new Error(`${intent.type} - not implemented`);
+	}
+}
+/**
+* How much of the redemption this claim was: what it credited, over that plus
+* what it left queued.
+*
+* The phantom stands for its payout one for one — the same reading the request
+* side takes when it names the claim it expects — so only the decimals of the
+* two have to be reconciled before they can be added up.
+*/
+function arrivedShare(claimed, queued, sdk) {
+	const rest = toTargetDecimals(queued.amount, queued.token, claimed.token, sdk);
+	return {
+		got: claimed.amount,
+		of: claimed.amount + rest
+	};
+}
+/** A share of an amount, rounded down: a tail never promises more than it has. */
+function part(amount, share) {
+	return share.of > 0n ? amount * share.got / share.of : 0n;
+}
 /**
 * Where a delayed intent ends up, worked out at the moment it is started.
 *
@@ -53,9 +160,9 @@ async function projectTail(args) {
 	const { request, delayed, creditAccount, sdk, quotaReserve } = args;
 	const { claim } = delayed;
 	const queued = request.outputs.find((o) => o.isDelayed);
-	if (!queued || !claim) throw new Error("projectTail: the request queued nothing to claim");
+	if (!queued || !claim) throw new IntentPreviewError("noRecordedIntent", void 0, "projectTail: the request queued nothing to claim");
 	const next = sliceAfter(creditAccount, delayed.afterRequest);
-	const steps = planTail({
+	const { steps } = planTail({
 		intent: delayed.record,
 		claimable: projectedClaimable(request, queued.token, queued.amount, claim),
 		view: accountView(next, sdk)
@@ -102,15 +209,16 @@ function projectedClaimable(request, phantom, phantomAmount, claim) {
 */
 function sliceAfter(creditAccount, after) {
 	const masks = new Map(creditAccount.tokens.map((t) => [t.token.toLowerCase(), t.mask]));
+	const quotas = new Map(after.quotas.map((q) => [q.token.address.toLowerCase(), q.value]));
 	return {
 		...creditAccount,
-		accountDebt: after.accountDebt,
+		totalDebt: after.totalDebt.value,
 		tokens: after.assets.map((a) => {
 			const token = a.token.address.toLowerCase();
 			return {
 				token,
 				balance: a.value,
-				quota: after.quotas[token]?.balance ?? 0n,
+				quota: quotas.get(token) ?? 0n,
 				mask: masks.get(token) ?? 0n,
 				success: true
 			};

package/dist/esm/onchain/accounts/intents/testing/market.js

@@ -78,12 +78,13 @@ const LIQUIDATION_THRESHOLDS = {
 const MAX_DEBT = toBN("200000", 8);
 /** Mock SDK on the shared fixture market. */
 function buildMarketSdk(extras) {
+	const prices = {
+		...PRICES,
+		...extras?.extraPrices
+	};
 	return buildMockSdk({
-		prices: {
-			...PRICES,
-			...extras?.extraPrices
-		},
-		reservePrices: extras?.reservePrices,
+		prices,
+		reservePrices: extras?.reservePrices ?? prices,
 		decimals: {
 			...DECIMALS,
 			...extras?.extraDecimals
@@ -95,6 +96,8 @@ function buildMarketSdk(extras) {
 		creditManager: CREDIT_MANAGER,
 		creditFacade: CREDIT_FACADE,
 		underlying: UND,
+		routeQuote: extras?.routeQuote,
+		routeFloor: extras?.routeFloor,
 		rwaAssets: extras?.rwaAssets,
 		phantoms: extras?.phantoms,
 		creditAccounts: extras?.creditAccounts,
@@ -141,7 +144,7 @@ function buildFixtureCreditAccount(args) {
 		underlying: UND,
 		enabledTokensMask: 0n,
 		totalDebtUSD: 0n,
-		accountDebt: args.accountDebt,
+		totalDebt: args.totalDebt,
 		tokens: args.tokens
 	};
 }