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

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

@@ -0,0 +1,56 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_constants_math = require("../../constants/math.js");
+const require_sdk_accounts_intents_types = require("./types.js");
+//#region src/sdk/accounts/intents/math.ts
+/** Debt that realises `leverage` on `collateral`: `D = C · (L − 1)`. */
+function debtForLeverage(collateral, leverage) {
+	return collateral * (leverage - require_sdk_constants_math.LEVERAGE_DECIMALS) / require_sdk_constants_math.LEVERAGE_DECIMALS;
+}
+/**
+* Debt change that keeps leverage fixed while collateral moves by
+* `collateralDelta`: `dD = D0 · dC / C0`.
+*
+* Computed on the ratio directly rather than by recovering `L` and reapplying
+* it, so no rounding is introduced on the way.
+*/
+function proportionalDebt(position, collateralDelta) {
+	if (position.collateral <= 0n) throw new require_sdk_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", "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.
+*
+* Solves `floor(D0 · W / C0) ≤ D0 − minDebt` for `W`.
+*/
+function maxProportionalWithdrawal(position, band) {
+	const { debt, collateral } = position;
+	if (collateral <= 0n) return 0n;
+	const allButLast = collateral - 1n;
+	if (debt === 0n) return allButLast;
+	const repayable = debt - band.minDebt;
+	if (repayable < 0n) return 0n;
+	const bound = ceilDiv(collateral * (repayable + 1n), debt) - 1n;
+	return bound < allButLast ? bound : allButLast;
+}
+const ceilDiv = (a, b) => (a + b - 1n) / b;
+/** Total leverage cannot drop below 1x — that would be negative debt. */
+function assertLeverageAtLeastOne(leverage) {
+	if (leverage < 100n) throw new require_sdk_accounts_intents_types.IntentPreviewError("leverageOutOfRange", `target leverage ${leverage} is below 1x`);
+}
+/**
+* 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(debt, band) {
+	if (debt > band.maxDebt) throw new require_sdk_accounts_intents_types.IntentPreviewError("debtOutOfRange", `debt ${debt} exceeds maxDebt ${band.maxDebt}`);
+	if (debt > 0n && debt < band.minDebt) throw new require_sdk_accounts_intents_types.IntentPreviewError("debtOutOfRange", `debt ${debt} is below minDebt ${band.minDebt}`);
+}
+//#endregion
+exports.assertDebtInBand = assertDebtInBand;
+exports.assertLeverageAtLeastOne = assertLeverageAtLeastOne;
+exports.debtForLeverage = debtForLeverage;
+exports.maxProportionalWithdrawal = maxProportionalWithdrawal;
+exports.proportionalDebt = proportionalDebt;

package/dist/cjs/sdk/accounts/intents/open-strategy.js

@@ -0,0 +1,133 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../../constants/math.js");
+const require_sdk_accounts_intents_types = require("./types.js");
+const require_sdk_accounts_intents_utils_convert_amount = require("./utils/convert-amount.js");
+const require_sdk_accounts_intents_guards = require("./guards.js");
+const require_sdk_accounts_intents_math = require("./math.js");
+const require_sdk_accounts_intents_utils_quotas_for_update = require("./utils/quotas-for-update.js");
+const require_sdk_accounts_intents_utils_router_path = require("./utils/router-path.js");
+require("./utils/index.js");
+//#region src/sdk/accounts/intents/open-strategy.ts
+/** Stand-in account address: nothing exists on chain until the tx lands. */
+const NO_ACCOUNT = "0x0000000000000000000000000000000000000000";
+/**
+* Previews opening a leveraged position out of wallet collateral.
+*
+* Debt follows from the target leverage against the supplied margin
+* (`debt = margin * (L - 1)`, `totalValue = margin * L`); the collateral and the
+* borrowed underlying are then routed into the target token in one pathfinder call.
+*
+* There is no account yet, so this does not go through `startIntent` and produces
+* no operation list — the caller passes the numbers and calls straight to
+* `sdk.accounts.openCA`.
+*/
+async function previewOpenStrategy(props) {
+	const { sdk, creditManager, collateral, targetToken, leverage, slippage = 0, quotaReserve, leftoverBalances = [] } = props;
+	if (leverage < 100n) throw new require_sdk_accounts_intents_types.IntentPreviewError("leverageOutOfRange", `openStrategy: leverage ${leverage} is below 1x`);
+	const suite = sdk.marketRegister.findCreditManager(creditManager);
+	const market = sdk.marketRegister.findByCreditManager(creditManager);
+	require_sdk_accounts_intents_guards.assertMarketOperable(suite);
+	const underlying = market.pool.underlying.toLowerCase();
+	const convert = require_sdk_accounts_intents_utils_convert_amount.convertAmount(sdk, creditManager);
+	const margin = collateral.reduce((acc, a) => acc + convert(a.token, underlying, a.balance), 0n);
+	if (margin <= 0n) throw new require_sdk_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", "openStrategy: collateral is worth nothing in underlying");
+	const debt = require_sdk_accounts_intents_math.debtForLeverage(margin, leverage);
+	const account = {
+		creditAccount: NO_ACCOUNT,
+		creditManager: creditManager.toLowerCase(),
+		creditFacade: suite.creditFacade.address.toLowerCase(),
+		underlying,
+		enabledTokensMask: 0n,
+		totalDebtUSD: 0n,
+		accountDebt: 0n,
+		tokens: []
+	};
+	require_sdk_accounts_intents_math.assertDebtInBand(debt, suite.creditFacade);
+	require_sdk_accounts_intents_guards.assertCanBorrow(suite, debt);
+	const leg = await require_sdk_accounts_intents_utils_router_path.createRouterPaths({
+		sdk,
+		creditAccount: account,
+		slippage
+	}).openStrategy({
+		expectedBalances: mergeExpectedBalances(collateral, underlying, debt),
+		leftoverBalances,
+		target: targetToken
+	});
+	const averageAssets = toAssets(leg.balances);
+	const minAssets = toAssets(leg.minBalances);
+	const quotasFor = (assets) => require_sdk_accounts_intents_utils_quotas_for_update.getQuotasForUpdate({
+		assetsBefore: [],
+		assetsAfter: assets,
+		initialQuotas: [],
+		quotaReserve,
+		underlyingToken: underlying,
+		liquidationThresholds: suite.creditManager.liquidationThresholds,
+		quotas: market.pool.pqk.quotas,
+		maxDebt: suite.creditFacade.maxDebt,
+		convert
+	}).quotaIncrease;
+	const averageQuota = quotasFor(averageAssets);
+	const minQuota = quotasFor(minAssets);
+	require_sdk_accounts_intents_guards.assertGrowthAllowed({
+		sdk,
+		suite,
+		market,
+		before: [],
+		after: averageAssets
+	});
+	require_sdk_accounts_intents_guards.assertQuotaHeadroom(market, averageQuota);
+	const snapshot = {
+		creditManager,
+		assets: averageAssets,
+		quotas: averageQuota,
+		totalDebt: debt,
+		totalValue: margin + debt
+	};
+	const metrics = {
+		healthFactor: sdk.positions.healthFactor(snapshot),
+		overallApy: 0,
+		borrowRate: sdk.positions.borrowRate(snapshot),
+		timeToLiquidation: sdk.positions.timeToLiquidation(snapshot),
+		liquidationPrice: sdk.positions.liquidationPrice(snapshot)
+	};
+	require_sdk_accounts_intents_guards.assertCollateralised(metrics.healthFactor);
+	return {
+		debt,
+		collateral: margin,
+		totalValue: margin + debt,
+		averageAssets,
+		minAssets,
+		averageQuota,
+		minQuota,
+		calls: [...leg.calls],
+		...metrics
+	};
+}
+/** Collateral plus the borrowed underlying, folded into one balance per token. */
+function mergeExpectedBalances(collateral, underlying, debt) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const a of collateral) {
+		const token = a.token.toLowerCase();
+		merged.set(token, (merged.get(token) ?? 0n) + a.balance);
+	}
+	if (debt > 0n) merged.set(underlying, (merged.get(underlying) ?? 0n) + debt);
+	return [...merged.entries()].map(([token, balance]) => ({
+		token,
+		balance
+	}));
+}
+/** Router balance records carry mixed-case keys; normalise and drop empties. */
+function toAssets(balances) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const [token, balance] of Object.entries(balances)) {
+		if (balance <= 0n) continue;
+		const key = token.toLowerCase();
+		merged.set(key, (merged.get(key) ?? 0n) + balance);
+	}
+	return [...merged.entries()].map(([token, balance]) => ({
+		token,
+		balance
+	}));
+}
+//#endregion
+exports.previewOpenStrategy = previewOpenStrategy;

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

@@ -0,0 +1,165 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_constants_math = require("../../constants/math.js");
+//#region src/sdk/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 ? require_sdk_constants_math.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 ? require_sdk_constants_math.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
+exports.buildAddCollateralOperation = buildAddCollateralOperation;
+exports.buildClaimDelayedWithdrawalOperation = buildClaimDelayedWithdrawalOperation;
+exports.buildCloseSwapOperation = buildCloseSwapOperation;
+exports.buildDecreaseDebtOperation = buildDecreaseDebtOperation;
+exports.buildIncreaseDebtOperation = buildIncreaseDebtOperation;
+exports.buildQuotaUpdateOperation = buildQuotaUpdateOperation;
+exports.buildStartDelayedWithdrawalOperation = buildStartDelayedWithdrawalOperation;
+exports.buildSwapOperation = buildSwapOperation;
+exports.buildUnwrapRwaCollateralOperation = buildUnwrapRwaCollateralOperation;
+exports.buildWithdrawCollateralOperation = buildWithdrawCollateralOperation;
+exports.buildWrapRwaCollateralOperation = buildWrapRwaCollateralOperation;
+exports.instantOutput = instantOutput;