@gearbox-protocol/sdk 16.1.2 → 16.3.0-next.1

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

@@ -1,8 +1,12 @@
 import { SDKConstruct } from "../../base/SDKConstruct.js";
-import { MIN_HF_LIMITED } from "../../validation/checks.js";
-import { IntentPreviewError, refuse } from "../../validation/refusal.js";
+import { unsupportedTokenPair } from "../../../model/errors/prepare-errors.js";
+import { sdkErr } from "../../../model/result.js";
+import "../../../model/index.js";
+import { MIN_HF_LIMITED } from "../../validation/helpers/health-factor-limits.js";
+import { IntentPreviewError } from "../../validation/raise.js";
+import "../../validation/index.js";
 import { isPhantomToken } from "./utils/pick-token.js";
-import { assertMarketOperable, borrowable } from "./guards.js";
+import { assertMarketOperable } from "./guards.js";
 import { calcLeverageBand } from "./leverage-band.js";
 import { maxProportionalWithdrawal } from "./math.js";
 import { maxWithdrawCollateral } from "./maxWithdrawCollateral.js";
@@ -25,7 +29,7 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	* Previews an operation on an existing account.
 	*
 	* @param props - Intent plus account slice, quota reserve and slippage
-	* @returns Operations, projected state and calldata, or `{ ok: false, reason }`
+	* @returns Operations, projected state and calldata, or `{ ok: false, error }`
 	* when the intent cannot be satisfied (e.g. the account lacks the source
 	* balance)
 	*/
@@ -46,8 +50,8 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	}
 	/**
 	* Both ends of what a `WITHDRAW` can take out, in underlying: the largest
-	* partial withdrawal that keeps leverage and stays inside the facade's debt
-	* band, and the net value an exit hands over. They are reported together
+	* partial withdrawal that keeps leverage and stays inside the facade's
+	* `debtLimits`, and the net value an exit hands over. They are reported together
 	* because a withdraw form needs both — the range it may offer, and the one
 	* amount past it that is allowed — and because the distance between them is
 	* the account's own, not a constant a caller could assume.
@@ -63,7 +67,7 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	maxWithdraw(props) {
 		const view = accountView(props.creditAccount, props.sdk);
 		return {
-			partial: maxProportionalWithdrawal(view, view.band),
+			partial: maxProportionalWithdrawal(view, view.debtLimits),
 			exit: view.collateral > 0n ? view.collateral : 0n
 		};
 	}
@@ -88,8 +92,8 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	*
 	* A credit manager's `maxLeverage` follows from the liquidation threshold
 	* alone, so it is the same for a hundred dollars and for a million. What a
-	* given deposit reaches is decided by the debt it implies and by the band
-	* the market puts that debt in — the range a leverage slider should offer.
+	* given deposit reaches is decided by the debt it implies and by the
+	* `debtLimits` the market puts that debt in — the range a leverage slider should offer.
 	*
 	* Unlike the other ceilings here this one reads no account: opening has none
 	* yet, and adjusting measures against the net value the caller already
@@ -108,9 +112,9 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	* while its health factor stays at `targetHF` — the ceiling a
 	* withdraw-collateral form should offer. Thresholds, prices and quota
 	* activity come from the account's market, valued the way the facade values
-	* a call that pays out; zero debt frees the whole balance.
+	* a call that withdraws collateral; zero debt frees the whole balance.
 	*
-	* The default is {@link MIN_HF_LIMITED}, the bar a form holds an
+	* The default is {@link MIN_HF_LIMITED}, the threshold a form holds an
 	* account to.
 	*
 	* @param props - Account slice, the SDK holding its market, the collateral
@@ -130,8 +134,8 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	*
 	* Sits apart from {@link startIntent} because it is a different trade route,
 	* not a different intent: the request goes to the issuer instead of the
-	* router, and the proceeds — hence the repayment and the payout — arrive days
-	* later. Both routes of one intent are quoted together by
+	* router, and what it sells for — hence the repayment and the withdrawal —
+	* arrives days later. Both routes of one intent are quoted together by
 	* {@link intentRoutes}; this is the one to call when the delayed route is the
 	* only one of interest.
 	*
@@ -143,7 +147,7 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	*
 	* @param props - Intent plus account slice, quota reserve and slippage
 	* @returns The request transaction, the state it ends in and what it recorded
-	* for the tail, or `{ ok: false, reason }` — `noDelayedRoute` when this route
+	* for the tail, or `{ ok: false, error }` — `noDelayedRoute` when this route
 	* does not exist for the account at all
 	*/
 	async startDelayedIntent(props) {
@@ -179,7 +183,7 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 				delayed
 			};
 		} catch (e) {
-			return asFailure(e);
+			return asSDKError(e);
 		}
 	}
 	/**
@@ -189,7 +193,7 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	* Which routes an account has depends on the intent and the token it sells,
 	* and a form has to know before it can offer a choice — so both are quoted
 	* from the same request and each is reported on its own. A route the account
-	* cannot take comes back `undefined` with its refusal in `refused`; only when
+	* cannot take comes back `undefined` with its error in `errors`; only when
 	* neither answers is the whole result `{ ok: false }`.
 	*
 	* A route that could not be quoted at all — a pathfinder with no path out of
@@ -199,31 +203,31 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	*
 	* @param props - A withdraw or adjust-leverage intent plus account slice,
 	* quota reserve and slippage
-	* @returns Whichever routes are viable, or `{ ok: false, reason }` when none is
+	* @returns Whichever routes are viable, or `{ ok: false, error }` when none is
 	*/
 	async intentRoutes(props) {
 		const [instant, delayed] = await Promise.allSettled([this.startIntent(props), this.startDelayedIntent(props)]);
 		const instantRoute = instant.status === "fulfilled" && instant.value.ok ? instant.value : void 0;
 		const delayedRoute = delayed.status === "fulfilled" && delayed.value.ok ? delayed.value : void 0;
-		const instantRefusal = instant.status === "fulfilled" && !instant.value.ok ? instant.value : void 0;
-		const delayedRefusal = delayed.status === "fulfilled" && !delayed.value.ok ? delayed.value : void 0;
-		const refused = {
-			instant: instantRefusal?.reason,
-			delayed: delayedRefusal?.reason
+		const instantError = instant.status === "fulfilled" && !instant.value.ok ? instant.value.error : void 0;
+		const delayedError = delayed.status === "fulfilled" && !delayed.value.ok ? delayed.value.error : void 0;
+		const errors = {
+			...instantError === void 0 ? {} : { instant: instantError },
+			...delayedError === void 0 ? {} : { delayed: delayedError }
 		};
 		if (instantRoute || delayedRoute) return {
 			ok: true,
 			instant: instantRoute,
 			delayed: delayedRoute,
-			refused
+			errors
 		};
 		const failed = [instant, delayed].find((s) => s.status === "rejected");
 		if (failed?.status === "rejected") throw failed.reason;
-		const chosen = instantRefusal ?? delayedRefusal;
+		const chosen = instantError ?? delayedError;
 		if (chosen === void 0) throw new Error("intentRoutes: a route neither answered nor refused");
 		return {
-			...chosen,
-			refused
+			...sdkErr(chosen),
+			errors
 		};
 	}
 	/**
@@ -236,7 +240,7 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	* catch up.
 	*
 	* A claim that brought only part of what the request queued — a legacy Mellow
-	* multivault, which pays out what it holds liquid and re-queues the rest — is
+	* multivault, which hands over what it holds liquid and re-queues the rest — is
 	* served in proportion, and what it did not settle comes back as `remainder`:
 	* the withdrawal still in flight and the intent to finish it with.
 	*
@@ -275,7 +279,7 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	*
 	* @param props - Credit manager, wallet collateral, target token and leverage
 	* @returns Debt, position size, projected balances and quotas for both the
-	* expected and the floor branch, or `{ ok: false, reason }` when the requested
+	* expected and the floor branch, or `{ ok: false, error }` when the requested
 	* leverage or the resulting debt is not viable
 	*/
 	async openStrategyIntent(props) {
@@ -285,7 +289,7 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 				state: await buildOpenStrategyState(props)
 			};
 		} catch (e) {
-			return asFailure(e);
+			return asSDKError(e);
 		}
 	}
 	/** Plan → realise → wrap. Unviable requests become `{ ok: false }`. */
@@ -306,7 +310,7 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 				delayed
 			};
 		} catch (e) {
-			return asFailure(e);
+			return asSDKError(e);
 		}
 	}
 };
@@ -322,16 +326,16 @@ function plain(result) {
 	};
 }
 /** Unviable requests are values; anything else is a genuine failure. */
-function asFailure(e) {
-	if (e instanceof IntentPreviewError) return refuse(e.reason, e.detail);
-	if (isUnroutable(e)) return refuse("unsupportedTokenPair", void 0);
+function asSDKError(e) {
+	if (e instanceof IntentPreviewError) return sdkErr(e.error);
+	if (isUnroutable(e)) return sdkErr(unsupportedTokenPair());
 	throw e;
 }
 /**
 * How the pathfinder says there is no route: it reverts instead of answering
 * with an empty path, so viem raises a contract error where the rest of the
 * engine raises an {@link IntentPreviewError}. Nothing is wrong — the trade
-* asked for cannot be made, which is a refusal the caller can act on, and one
+* asked for cannot be made, which is an error the caller can act on, and one
 * `intentRoutes` in particular must keep as a value so the other route can
 * still be offered.
 */
@@ -340,4 +344,4 @@ function isUnroutable(e) {
 	return false;
 }
 //#endregion
-export { CreditAccountOperationsService, borrowable, fetchCreditAccountSlice, isPhantomToken, toCreditAccountSlice };
+export { CreditAccountOperationsService, fetchCreditAccountSlice, isPhantomToken, toCreditAccountSlice };

package/dist/esm/onchain/accounts/intents/leverage-band.js

@@ -7,7 +7,7 @@ import { LEVERAGE_DECIMALS } from "../../constants/math.js";
 * A credit manager's `maxLeverage` follows from the liquidation threshold
 * alone, so it is the same for a hundred dollars and for a million. What a
 * given deposit reaches is decided by the debt it implies —
-* `debt = netValue × (leverage − 1)` — and by the band the market puts that
+* `debt = netValue × (leverage − 1)` — and by the `debtLimits` the market puts that
 * debt in. This inverts that relation.
 *
 * Rounding is asymmetric because the forward direction truncates: the floor

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

@@ -1,8 +1,12 @@
 import { BigIntMath } from "../../utils/bigint-math.js";
 import { LEVERAGE_DECIMALS } from "../../constants/math.js";
-import { checkDebtInBand, checkLeverageAtLeastOne } from "../../validation/checks.js";
-import { IntentPreviewError, raise } from "../../validation/refusal.js";
-import { toToken } from "../../validation/token.js";
+import { insufficientBalance } from "../../../model/errors/operation-errors.js";
+import "../../../model/index.js";
+import { toToken } from "../../validation/helpers/token.js";
+import { checkDebtLimits } from "../../validation/checks/checkDebtLimits.js";
+import { checkLeverage } from "../../validation/checks/checkLeverage.js";
+import { IntentPreviewError, raise } from "../../validation/raise.js";
+import "../../validation/index.js";
 //#region src/onchain/accounts/intents/math.ts
 /** Debt that realises `leverage` on `collateral`: `D = C · (L − 1)`. */
 function debtForLeverage(collateral, leverage) {
@@ -16,30 +20,30 @@ function debtForLeverage(collateral, leverage) {
 * it, so no rounding is introduced on the way.
 */
 function proportionalDebt(position, collateralDelta) {
-	if (position.collateral <= 0n) throw new IntentPreviewError("insufficientSourceBalance", void 0, "cannot preserve leverage on an account with no collateral");
+	if (position.collateral <= 0n) throw new IntentPreviewError(insufficientBalance(), "cannot preserve leverage on an account with no collateral");
 	return position.debt * collateralDelta / position.collateral;
 }
 /**
 * Largest withdrawal (in underlying) that {@link proportionalDebt} can still
 * pay for: the repayment it implies leaves debt at or above `minDebt`, and
 * strictly less than the collateral goes — the last unit closes the account
-* rather than shrinks it. `0n` when the debt already sits below the band.
+* rather than shrinks it. `0n` when the debt already sits below `minDebt`.
 *
 * Solves `floor(D0 · W / C0) ≤ D0 − minDebt` for `W`.
 */
-function maxProportionalWithdrawal(position, band) {
+function maxProportionalWithdrawal(position, debtLimits) {
 	const { debt, collateral } = position;
 	if (collateral <= 0n) return 0n;
 	const allButLast = collateral - 1n;
 	if (debt === 0n) return allButLast;
-	const repayable = debt - band.minDebt;
+	const repayable = debt - debtLimits.minDebt;
 	if (repayable < 0n) return 0n;
 	const bound = BigIntMath.ceilDiv(collateral * (repayable + 1n), debt) - 1n;
 	return bound < allButLast ? bound : allButLast;
 }
 /** Total leverage cannot drop below 1x — that would be negative debt. */
 function assertLeverageAtLeastOne(leverage) {
-	raise(checkLeverageAtLeastOne({
+	raise(checkLeverage({
 		leverage,
 		min: LEVERAGE_DECIMALS
 	}), `target leverage ${leverage} is below 1x`);
@@ -48,14 +52,14 @@ function assertLeverageAtLeastOne(leverage) {
 * Rejects a debt the facade would revert on: zero is always fine (no loan at
 * all), anything else has to sit inside `[minDebt, maxDebt]`.
 */
-function assertDebtInBand(sdk, debt, band, underlying) {
-	raise(checkDebtInBand({
+function assertDebtLimits(sdk, debt, debtLimits, underlying) {
+	raise(checkDebtLimits({
 		debt,
-		minDebt: band.minDebt,
-		maxDebt: band.maxDebt,
+		minDebt: debtLimits.minDebt,
+		maxDebt: debtLimits.maxDebt,
 		underlying: toToken(sdk, underlying),
 		allowZero: true
-	}), debt > band.maxDebt ? `debt ${debt} exceeds maxDebt ${band.maxDebt}` : `debt ${debt} is below minDebt ${band.minDebt}`);
+	}), debt > debtLimits.maxDebt ? `debt ${debt} exceeds maxDebt ${debtLimits.maxDebt}` : `debt ${debt} is below minDebt ${debtLimits.minDebt}`);
 }
 //#endregion
-export { assertDebtInBand, assertLeverageAtLeastOne, debtForLeverage, maxProportionalWithdrawal, proportionalDebt };
+export { assertDebtLimits, assertLeverageAtLeastOne, debtForLeverage, maxProportionalWithdrawal, proportionalDebt };

package/dist/esm/onchain/accounts/intents/open-strategy.js

@@ -1,12 +1,17 @@
-import { IntentPreviewError } from "../../validation/refusal.js";
-import { assertCanBorrow, assertCollateralised, assertGrowthAllowed, assertMarketOperable, assertQuotaHeadroom } from "./guards.js";
-import { assertDebtInBand, assertLeverageAtLeastOne, debtForLeverage } from "./math.js";
+import { insufficientBalance } from "../../../model/errors/operation-errors.js";
+import "../../../model/index.js";
+import { IntentPreviewError } from "../../validation/raise.js";
+import { assertCanBorrow, assertCollateralised, assertGrowthAllowed, assertMarketOperable, assertQuotaAvailable } from "./guards.js";
+import { assertDebtLimits, assertLeverageAtLeastOne, debtForLeverage } from "./math.js";
 import { collectPriceImpact } from "./utils/price-impact.js";
 import { getQuotasForUpdate } from "./utils/quotas-for-update.js";
 import { createRouterPaths } from "./utils/router-path.js";
 import "./utils/index.js";
 //#region src/onchain/accounts/intents/open-strategy.ts
-/** Stand-in account address: nothing exists on chain until the tx lands. */
+/**
+* Stand-in account address, used when the opening creates its own account:
+* nothing exists on chain until the tx lands.
+*/
 const NO_ACCOUNT = "0x0000000000000000000000000000000000000000";
 /**
 * Builds the state opening a leveraged position out of wallet collateral would
@@ -21,7 +26,8 @@ const NO_ACCOUNT = "0x0000000000000000000000000000000000000000";
 * `sdk.accounts.openCA`.
 */
 async function buildOpenStrategyState(props) {
-	const { sdk, creditManager, collateral, targetToken, leverage, slippage = 0, quotaReserve, leftoverBalances = [] } = props;
+	if (props.empty) return emptyOpenState(props);
+	const { sdk, creditManager, collateral, targetToken, leverage, slippage = 0, quotaReserve, leftoverBalances = [], creditAccount: existing } = props;
 	assertLeverageAtLeastOne(leverage);
 	const suite = sdk.marketRegister.findCreditManager(creditManager);
 	const market = sdk.marketRegister.findByCreditManager(creditManager);
@@ -29,9 +35,9 @@ async function buildOpenStrategyState(props) {
 	const underlying = market.pool.underlying.toLowerCase();
 	const convert = (from, to, amount) => market.priceOracle.safeConvert(from, to, amount).value;
 	const margin = collateral.reduce((acc, a) => acc + convert(a.token, underlying, a.balance), 0n);
-	if (margin <= 0n) throw new IntentPreviewError("insufficientSourceBalance", void 0, "openStrategy: collateral is worth nothing in underlying");
+	if (margin <= 0n) throw new IntentPreviewError(insufficientBalance(), "openStrategy: collateral is worth nothing in underlying");
 	const debt = debtForLeverage(margin, leverage);
-	const account = {
+	const account = existing ?? {
 		creditAccount: NO_ACCOUNT,
 		creditManager: creditManager.toLowerCase(),
 		creditFacade: suite.creditFacade.address.toLowerCase(),
@@ -41,7 +47,7 @@ async function buildOpenStrategyState(props) {
 		totalDebt: 0n,
 		tokens: []
 	};
-	assertDebtInBand(sdk, debt, suite.creditFacade, underlying);
+	assertDebtLimits(sdk, debt, suite.creditFacade, underlying);
 	assertCanBorrow(sdk, suite, debt);
 	const paths = createRouterPaths({
 		sdk,
@@ -77,7 +83,7 @@ async function buildOpenStrategyState(props) {
 		before: [],
 		after: averageAssets
 	});
-	assertQuotaHeadroom(sdk, market, averageQuota);
+	assertQuotaAvailable(sdk, market, averageQuota);
 	const snapshot = {
 		creditManager,
 		assets: averageAssets,
@@ -100,7 +106,37 @@ async function buildOpenStrategyState(props) {
 		minAssets: minAssets.map(priced),
 		averageQuota,
 		minQuota,
-		calls: [...leg.calls]
+		calls: [...leg.calls],
+		creditAccount: existing?.creditAccount
+	};
+}
+/**
+* The opening that holds an account and nothing else.
+*
+* Taken before the walk rather than threaded through it: the router has no
+* guard for an empty basket and would still make its `eth_call`, and every
+* assertion below reads amounts that are not there.
+*/
+async function emptyOpenState(props) {
+	const { sdk, creditManager } = props;
+	assertMarketOperable(sdk.marketRegister.findCreditManager(creditManager));
+	const snapshot = {
+		creditManager,
+		assets: [],
+		quotas: [],
+		totalDebt: 0n,
+		totalValue: 0n
+	};
+	const { assets: _assets, quotas: _quotas, ...projection } = sdk.positions.projection(snapshot, { availableLiquidityChange: 0n });
+	return {
+		...projection,
+		currentPrice: sdk.positions.currentPrice(snapshot),
+		priceImpact: void 0,
+		averageAssets: [],
+		minAssets: [],
+		averageQuota: [],
+		minQuota: [],
+		calls: []
 	};
 }
 /** Collateral plus the borrowed underlying, folded into one balance per token. */