@gearbox-protocol/sdk 16.3.2 → 16.4.0-next.10

package/dist/esm/dev/withdrawalUtils.js

@@ -204,18 +204,15 @@ async function fulfillMidasRedeemer(anvil, redeemer, logger) {
 		address: MIDAS_VAULT_ADMIN,
 		value: parseEther("100")
 	});
-	const hash = await anvil.writeContract({
+	await anvil.writeContractSync({
 		chain: anvil.chain,
 		address: midasRedemptionVault,
 		account: MIDAS_VAULT_ADMIN,
 		abi: iMidasRedemptionVaultExtAbi,
 		functionName: "safeApproveRequest",
-		args: [requestId, mTokenRate]
+		args: [requestId, mTokenRate],
+		throwOnReceiptRevert: true
 	});
-	if ((await anvil.waitForTransactionReceipt({
-		hash,
-		pollingInterval: 100
-	})).status !== "success") throw new Error(`midas: safeApproveRequest tx ${hash} reverted`);
 	await anvil.stopImpersonatingAccount({ address: MIDAS_VAULT_ADMIN });
 }
 /**

package/dist/esm/model/errors/index.js

@@ -1,7 +1,7 @@
 import "./base.js";
 import { creditAccountFrozen, liquidatorNotEligible, notEmergencyLiquidator } from "./liquidation-errors.js";
-import { creditManagerPaused, debtOutOfRange, forbiddenToken, insufficientAllowance, insufficientBalance, insufficientCollateral, insufficientPoolLiquidity, leverageOutOfRange, marketExpired, poolPaused, poolSunset, quotaCountExceeded, quotaLimitReached, rwaOpenRequirementsNotMet } from "./operation-errors.js";
+import { accountNotMidasGreenlisted, creditManagerPaused, debtOutOfRange, forbiddenToken, insufficientAllowance, insufficientBalance, insufficientCollateral, insufficientPoolLiquidity, leverageOutOfRange, marketExpired, poolPaused, poolSunset, quotaCountExceeded, quotaLimitReached, reservePriceLimited, rwaOpenRequirementsNotMet } from "./operation-errors.js";
 import { unpriceableTokenError } from "./oracle-errors.js";
 import { creditAccountNotEmpty, creditAccountNotFound, multipleDelayedWithdrawals, noDelayedRoute, noRecordedIntent, noStrategyTargetCollateral, unexpectedFailure, unsupportedCollateralToken, unsupportedTokenPair, withdrawalInProgress } from "./prepare-errors.js";
 import { malformedTransaction } from "./preview-errors.js";
-export { creditAccountFrozen, creditAccountNotEmpty, creditAccountNotFound, creditManagerPaused, debtOutOfRange, forbiddenToken, insufficientAllowance, insufficientBalance, insufficientCollateral, insufficientPoolLiquidity, leverageOutOfRange, liquidatorNotEligible, malformedTransaction, marketExpired, multipleDelayedWithdrawals, noDelayedRoute, noRecordedIntent, noStrategyTargetCollateral, notEmergencyLiquidator, poolPaused, poolSunset, quotaCountExceeded, quotaLimitReached, rwaOpenRequirementsNotMet, unexpectedFailure, unpriceableTokenError, unsupportedCollateralToken, unsupportedTokenPair, withdrawalInProgress };
+export { accountNotMidasGreenlisted, creditAccountFrozen, creditAccountNotEmpty, creditAccountNotFound, creditManagerPaused, debtOutOfRange, forbiddenToken, insufficientAllowance, insufficientBalance, insufficientCollateral, insufficientPoolLiquidity, leverageOutOfRange, liquidatorNotEligible, malformedTransaction, marketExpired, multipleDelayedWithdrawals, noDelayedRoute, noRecordedIntent, noStrategyTargetCollateral, notEmergencyLiquidator, poolPaused, poolSunset, quotaCountExceeded, quotaLimitReached, reservePriceLimited, rwaOpenRequirementsNotMet, unexpectedFailure, unpriceableTokenError, unsupportedCollateralToken, unsupportedTokenPair, withdrawalInProgress };

package/dist/esm/model/errors/operation-errors.js

@@ -66,6 +66,14 @@ function insufficientCollateral(args) {
 		...args
 	};
 }
+/** {@inheritDoc ReservePriceLimitedError} */
+function reservePriceLimited(args) {
+	return {
+		code: "reservePriceLimited",
+		message: `The reserve price feed values this collateral below what the operation pays out: the account covers its debt at ${args.atMainPrices} on the main feed and only ${args.healthFactor} at the reserve one, below ${args.healthFactorThreshold}.`,
+		...args
+	};
+}
 /** {@inheritDoc ForbiddenTokenError} */
 function forbiddenToken(token) {
 	return {
@@ -117,5 +125,13 @@ function rwaOpenRequirementsNotMet(args) {
 		...args
 	};
 }
+/** {@inheritDoc AccountNotMidasGreenlistedError} */
+function accountNotMidasGreenlisted(args) {
+	return {
+		code: "accountNotMidasGreenlisted",
+		message: `The credit account is not Midas-greenlisted for ${args.token.symbol}.`,
+		...args
+	};
+}
 //#endregion
-export { creditManagerPaused, debtOutOfRange, forbiddenToken, insufficientAllowance, insufficientBalance, insufficientCollateral, insufficientPoolLiquidity, leverageOutOfRange, marketExpired, poolPaused, poolSunset, quotaCountExceeded, quotaLimitReached, rwaOpenRequirementsNotMet };
+export { accountNotMidasGreenlisted, creditManagerPaused, debtOutOfRange, forbiddenToken, insufficientAllowance, insufficientBalance, insufficientCollateral, insufficientPoolLiquidity, leverageOutOfRange, marketExpired, poolPaused, poolSunset, quotaCountExceeded, quotaLimitReached, reservePriceLimited, rwaOpenRequirementsNotMet };

package/dist/esm/model/index.js

@@ -15,7 +15,7 @@ import { ANALYTICS_POSITIONS_DEFAULT_LIMIT, ANALYTICS_POSITIONS_MAX_LIMIT, analy
 import "./curators.js";
 import "./delayed-intents.js";
 import { creditAccountFrozen, liquidatorNotEligible, notEmergencyLiquidator } from "./errors/liquidation-errors.js";
-import { creditManagerPaused, debtOutOfRange, forbiddenToken, insufficientAllowance, insufficientBalance, insufficientCollateral, insufficientPoolLiquidity, leverageOutOfRange, marketExpired, poolPaused, poolSunset, quotaCountExceeded, quotaLimitReached, rwaOpenRequirementsNotMet } from "./errors/operation-errors.js";
+import { accountNotMidasGreenlisted, creditManagerPaused, debtOutOfRange, forbiddenToken, insufficientAllowance, insufficientBalance, insufficientCollateral, insufficientPoolLiquidity, leverageOutOfRange, marketExpired, poolPaused, poolSunset, quotaCountExceeded, quotaLimitReached, reservePriceLimited, rwaOpenRequirementsNotMet } from "./errors/operation-errors.js";
 import { unpriceableTokenError } from "./errors/oracle-errors.js";
 import { creditAccountNotEmpty, creditAccountNotFound, multipleDelayedWithdrawals, noDelayedRoute, noRecordedIntent, noStrategyTargetCollateral, unexpectedFailure, unsupportedCollateralToken, unsupportedTokenPair, withdrawalInProgress } from "./errors/prepare-errors.js";
 import { malformedTransaction } from "./errors/preview-errors.js";
@@ -32,4 +32,4 @@ import { chainFailedSchema, chainMetadataSchema, chainSucceededSchema, dataSourc
 import { safeValue, sdkErr, sdkOk } from "./result.js";
 import "./withdrawals.js";
 import { positionClaimableWithdrawalSchema, positionPendingWithdrawalSchema, positionWithdrawalsSchema, withdrawalOutputAmountSchema } from "./withdrawals.schema.js";
-export { ANALYTICS_POSITIONS_DEFAULT_LIMIT, ANALYTICS_POSITIONS_MAX_LIMIT, CHART_METRIC_UNITS, CHART_RANGES, CHART_UNAVAILABLE_CODES, FILTER_ALL, KYC_REGISTRATION_LINKS, POOL_OPPORTUNITY_CHART_METRICS, POOL_POSITION_CHART_METRICS, PROTOCOL_CHART_METRICS, RWA_FACTORY_SECURITIZE, RWA_FACTORY_TYPES, RWA_PROTOCOLS, SECURITIZE_REGISTER_VAULT_TYPES, STRATEGY_OPPORTUNITY_CHART_METRICS, STRATEGY_POSITION_CHART_METRICS, STRATEGY_POSITION_COLLATERAL_ERROR, amountSchema, analyticsChartQueryOptionsSchema, analyticsChartQueryParamsSchema, analyticsChartQuerySchema, analyticsPositionListOptionsSchema, analyticsPositionListQueryParamsSchema, analyticsPositionListQuerySchema, analyticsPositionPageSchema, analyticsPositionSchema, analyticsPositionSortFieldSchema, analyticsSortDirectionSchema, apyBreakdownSchema, asEstimated, assetTypeSchema, backendPreferred, booleanParamSchema, borrowRateBreakdownSchema, bpsSchema, chainFailedSchema, chainIdSchema, chainMetadataSchema, chainSucceededSchema, chartBundleSchemaFor, chartDenominationSchema, chartMetricSchema, chartQueryCodec, chartQueryParamsSchema, chartQuerySchema, chartRangeSchema, chartSeriesSchema, chartValueSchema, chartWindowSchema, compareTagOf, creditAccountFrozen, creditAccountNotEmpty, creditAccountNotFound, creditManagerPaused, curatorNameSchema, curatorSchema, dataSourceSchema, debtOutOfRange, delayedReceivedAssetSchema, encodeFlag, filterAllSchema, filterable, forbiddenToken, instantReceivedAssetSchema, insufficientAllowance, insufficientBalance, insufficientCollateral, insufficientPoolLiquidity, isFilterSet, kycRequirementSchema, leverageOutOfRange, leverageSchema, liquidatableAccountFilterSchema, liquidatableAccountSchema, liquidationApprovalSchema, liquidationDetailsSchema, liquidationPositionId, liquidationPositionSchema, liquidatorNotEligible, malformedTransaction, marketExpired, matchesLiquidatableAccountFilter, matchesOpportunityFilter, matchesPositionFilter, multipleDelayedWithdrawals, noDelayedRoute, noRecordedIntent, noStrategyTargetCollateral, notEmergencyLiquidator, noticeKindSchema, noticeSchema, offchainOnly, onchainOnly, opportunityBaseSchema, opportunityDetailSchema, opportunityFilterQueryParamsSchema, opportunityFilterQuerySchema, opportunityFilterSchema, opportunityId, opportunityKeySchema, opportunityKindSchema, opportunitySchema, opportunityTotalsSchema, pnlBreakdownSchema, pointRewardsSchema, pointsProgramPnLSchema, pointsProgramSchema, pointsRewardsPnLSchema, poolOpportunityChartMetricSchema, poolOpportunityDetailSchema, poolOpportunityId, poolOpportunityKeySchema, poolOpportunitySchema, poolPaused, poolPositionChartMetricSchema, poolPositionId, poolPositionKeySchema, poolPositionSchema, poolSunset, positionClaimableWithdrawalSchema, positionCollateralSchema, positionFilterQueryParamsSchema, positionFilterQuerySchema, positionFilterSchema, positionId, positionKeySchema, positionKindSchema, positionPendingWithdrawalSchema, positionSchema, positionTransactionKindSchema, positionTransactionSchema, positionWithdrawalsSchema, positionsTotalsSchema, priceFeedDataSchema, priceFeedSummarySchema, protocolChartMetricSchema, quotaAssetSchema, quotaCountExceeded, quotaLimitReached, rateCurvePointSchema, rateCurveSchema, receivedAssetSchema, responseMetadataSchema, responseSchema, rewardsPnLSchema, rewardsSchema, rwaOpenRequirementsNotMet, rwaProtocolSchema, safeValue, sdkErr, sdkOk, strategyOpportunityChartMetricSchema, strategyOpportunityDetailSchema, strategyOpportunityId, strategyOpportunityKeySchema, strategyOpportunitySchema, strategyPositionChartMetricSchema, strategyPositionId, strategyPositionKeySchema, strategyPositionSchema, timestampSchema, tokenAmountSchema, tokenQuotaRateSchema, tokenRewardsPnLSchema, tokenRewardsSchema, tokenSchema, tolerance, txCallSchema, underlyingTokenSchema, unexpectedFailure, unpriceableTokenError, unsupportedCollateralToken, unsupportedTokenPair, withdrawalInProgress, withdrawalOutputAmountSchema };
+export { ANALYTICS_POSITIONS_DEFAULT_LIMIT, ANALYTICS_POSITIONS_MAX_LIMIT, CHART_METRIC_UNITS, CHART_RANGES, CHART_UNAVAILABLE_CODES, FILTER_ALL, KYC_REGISTRATION_LINKS, POOL_OPPORTUNITY_CHART_METRICS, POOL_POSITION_CHART_METRICS, PROTOCOL_CHART_METRICS, RWA_FACTORY_SECURITIZE, RWA_FACTORY_TYPES, RWA_PROTOCOLS, SECURITIZE_REGISTER_VAULT_TYPES, STRATEGY_OPPORTUNITY_CHART_METRICS, STRATEGY_POSITION_CHART_METRICS, STRATEGY_POSITION_COLLATERAL_ERROR, accountNotMidasGreenlisted, amountSchema, analyticsChartQueryOptionsSchema, analyticsChartQueryParamsSchema, analyticsChartQuerySchema, analyticsPositionListOptionsSchema, analyticsPositionListQueryParamsSchema, analyticsPositionListQuerySchema, analyticsPositionPageSchema, analyticsPositionSchema, analyticsPositionSortFieldSchema, analyticsSortDirectionSchema, apyBreakdownSchema, asEstimated, assetTypeSchema, backendPreferred, booleanParamSchema, borrowRateBreakdownSchema, bpsSchema, chainFailedSchema, chainIdSchema, chainMetadataSchema, chainSucceededSchema, chartBundleSchemaFor, chartDenominationSchema, chartMetricSchema, chartQueryCodec, chartQueryParamsSchema, chartQuerySchema, chartRangeSchema, chartSeriesSchema, chartValueSchema, chartWindowSchema, compareTagOf, creditAccountFrozen, creditAccountNotEmpty, creditAccountNotFound, creditManagerPaused, curatorNameSchema, curatorSchema, dataSourceSchema, debtOutOfRange, delayedReceivedAssetSchema, encodeFlag, filterAllSchema, filterable, forbiddenToken, instantReceivedAssetSchema, insufficientAllowance, insufficientBalance, insufficientCollateral, insufficientPoolLiquidity, isFilterSet, kycRequirementSchema, leverageOutOfRange, leverageSchema, liquidatableAccountFilterSchema, liquidatableAccountSchema, liquidationApprovalSchema, liquidationDetailsSchema, liquidationPositionId, liquidationPositionSchema, liquidatorNotEligible, malformedTransaction, marketExpired, matchesLiquidatableAccountFilter, matchesOpportunityFilter, matchesPositionFilter, multipleDelayedWithdrawals, noDelayedRoute, noRecordedIntent, noStrategyTargetCollateral, notEmergencyLiquidator, noticeKindSchema, noticeSchema, offchainOnly, onchainOnly, opportunityBaseSchema, opportunityDetailSchema, opportunityFilterQueryParamsSchema, opportunityFilterQuerySchema, opportunityFilterSchema, opportunityId, opportunityKeySchema, opportunityKindSchema, opportunitySchema, opportunityTotalsSchema, pnlBreakdownSchema, pointRewardsSchema, pointsProgramPnLSchema, pointsProgramSchema, pointsRewardsPnLSchema, poolOpportunityChartMetricSchema, poolOpportunityDetailSchema, poolOpportunityId, poolOpportunityKeySchema, poolOpportunitySchema, poolPaused, poolPositionChartMetricSchema, poolPositionId, poolPositionKeySchema, poolPositionSchema, poolSunset, positionClaimableWithdrawalSchema, positionCollateralSchema, positionFilterQueryParamsSchema, positionFilterQuerySchema, positionFilterSchema, positionId, positionKeySchema, positionKindSchema, positionPendingWithdrawalSchema, positionSchema, positionTransactionKindSchema, positionTransactionSchema, positionWithdrawalsSchema, positionsTotalsSchema, priceFeedDataSchema, priceFeedSummarySchema, protocolChartMetricSchema, quotaAssetSchema, quotaCountExceeded, quotaLimitReached, rateCurvePointSchema, rateCurveSchema, receivedAssetSchema, reservePriceLimited, responseMetadataSchema, responseSchema, rewardsPnLSchema, rewardsSchema, rwaOpenRequirementsNotMet, rwaProtocolSchema, safeValue, sdkErr, sdkOk, strategyOpportunityChartMetricSchema, strategyOpportunityDetailSchema, strategyOpportunityId, strategyOpportunityKeySchema, strategyOpportunitySchema, strategyPositionChartMetricSchema, strategyPositionId, strategyPositionKeySchema, strategyPositionSchema, timestampSchema, tokenAmountSchema, tokenQuotaRateSchema, tokenRewardsPnLSchema, tokenRewardsSchema, tokenSchema, tolerance, txCallSchema, underlyingTokenSchema, unexpectedFailure, unpriceableTokenError, unsupportedCollateralToken, unsupportedTokenPair, withdrawalInProgress, withdrawalOutputAmountSchema };

package/dist/esm/onchain/accounts/CreditAccountsServiceV310.js

@@ -212,7 +212,6 @@ var CreditAccountsServiceV310 = class extends SDKConstruct {
 			}),
 			...callsAfter ?? []
 		];
-		calls = await this.#prependMidasReceiveGreenlist(cm.address, calls);
 		calls = await this.prependPriceUpdates(cm.address, calls);
 		const tx = reopenCreditAccount ? cmSuite.multicallTx(reopenCreditAccount, calls, rwaOptions) : cmSuite.openCreditAccountTx(to, calls, referralCode, rwaOptions);
 		tx.value = ethAmount.toString(10);

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

@@ -0,0 +1,137 @@
+import { insufficientBalance } from "../../../model/errors/operation-errors.js";
+import { unsupportedCollateralToken } from "../../../model/errors/prepare-errors.js";
+import "../../../model/index.js";
+import { toToken } from "../../validation/helpers/token.js";
+import { IntentPreviewError } from "../../validation/raise.js";
+import "../../validation/index.js";
+import { eq, toTargetDecimals } from "./utils/common.js";
+import { assertCanBorrow, assertCollateralised, assertGrowthAllowed, assertMarketOperable, assertQuotaAvailable } from "./guards.js";
+import { assertDebtLimits } from "./math.js";
+import { unopenedAccountSlice } from "./utils/credit-account-slice.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/borrow.ts
+/**
+* Builds the state a borrow would leave behind.
+*
+* The debt is named rather than derived: a borrow asks for an amount, where an
+* opening asks for a leverage and lets the collateral decide. Everything the
+* loan pays out leaves the account, so the collateral alone backs it — which
+* is what makes the health factor here a straight function of the two amounts.
+*
+* Produces no operation list, as opening never does: the caller hands the
+* numbers and the calls to `sdk.accounts.openCA`, with `withdrawToken` set to
+* the payout.
+*/
+async function buildBorrowState(props) {
+	const { sdk, creditManager, collateralAmount, borrowAmount, slippage = 0, quotaReserve, creditAccount: existing } = props;
+	const suite = sdk.marketRegister.findCreditManager(creditManager);
+	const market = sdk.marketRegister.findByCreditManager(creditManager);
+	assertMarketOperable(suite);
+	const underlying = market.pool.underlying.toLowerCase();
+	const collateralToken = props.collateralToken.toLowerCase();
+	const borrowToken = props.borrowToken.toLowerCase();
+	const convert = (from, to, amount) => market.priceOracle.safeConvert(from, to, amount).value;
+	if (eq(collateralToken, borrowToken)) throw new IntentPreviewError(unsupportedCollateralToken(toToken(sdk, collateralToken)), "borrow: the payout token cannot also be the collateral");
+	const rwaAsset = sdk.tokensMeta.rwaUnderlyings.get(underlying)?.asset?.toLowerCase();
+	const unwrapsPayout = !!rwaAsset && eq(borrowToken, rwaAsset);
+	if (rwaAsset && eq(borrowToken, underlying)) throw new IntentPreviewError(unsupportedCollateralToken(toToken(sdk, borrowToken)), `borrow: ${underlying} cannot leave the account, ask for the payout in ${rwaAsset}`);
+	if (collateralAmount <= 0n) throw new IntentPreviewError(insufficientBalance(), "borrow: no collateral supplied");
+	if (borrowAmount <= 0n) throw new IntentPreviewError(insufficientBalance(), "borrow: nothing to borrow");
+	const margin = convert(collateralToken, underlying, collateralAmount);
+	if (margin <= 0n) throw new IntentPreviewError(insufficientBalance(), "borrow: collateral is worth nothing in underlying");
+	const debt = eq(borrowToken, underlying) ? borrowAmount : unwrapsPayout ? toTargetDecimals(borrowAmount, borrowToken, underlying, sdk) : convert(borrowToken, underlying, borrowAmount);
+	assertDebtLimits(sdk, debt, suite.creditFacade, underlying);
+	assertCanBorrow(sdk, suite, debt);
+	const account = existing ?? unopenedAccountSlice({
+		creditManager,
+		creditFacade: suite.creditFacade.address,
+		underlying
+	});
+	const leg = eq(borrowToken, underlying) || unwrapsPayout ? void 0 : await createRouterPaths({
+		sdk,
+		creditAccount: account,
+		slippage
+	}).swap({
+		tokenIn: underlying,
+		tokenOut: borrowToken,
+		amount: debt,
+		keep: eq(collateralToken, underlying) ? collateralAmount : 0n
+	});
+	const unwrap = unwrapsPayout ? await sdk.accounts.assembleRWAUnwrapCalls(debt, creditManager) : void 0;
+	if (unwrapsPayout && !unwrap) throw new Error(`borrow: no unwrap calls found for ${borrowToken}`);
+	const assets = [{
+		token: collateralToken,
+		balance: collateralAmount
+	}];
+	const quotaIncrease = borrowCollateralQuota({
+		sdk,
+		creditManager,
+		assets,
+		quotaReserve
+	});
+	assertGrowthAllowed({
+		sdk,
+		suite,
+		market,
+		before: [],
+		after: assets
+	});
+	assertQuotaAvailable(sdk, market, quotaIncrease);
+	const snapshot = {
+		creditManager,
+		assets,
+		quotas: quotaIncrease,
+		totalDebt: debt,
+		totalValue: margin
+	};
+	const projection = sdk.positions.projection(snapshot, { availableLiquidityChange: -debt });
+	assertCollateralised(projection.safeHealthFactor, true);
+	const priced = (token, balance) => market.priceOracle.toTokenAmount(token, balance);
+	const payout = unwrapsPayout ? toTargetDecimals(debt, underlying, borrowToken, sdk) : leg ? leg.amount : debt;
+	return {
+		...projection,
+		currentPrice: sdk.positions.currentPrice(snapshot),
+		executionCost: void 0,
+		priceImpact: await collectPriceImpact(leg?.probe ? [leg.probe] : [], {
+			totalValue: margin,
+			netValue: margin - debt,
+			toUnderlying: (from, amount) => convert(from, underlying, amount)
+		}),
+		collateral: priced(collateralToken, collateralAmount),
+		borrowed: priced(borrowToken, payout),
+		minBorrowed: priced(borrowToken, leg ? leg.minAmount : payout),
+		slippage,
+		quotaIncrease,
+		calls: leg ? [...leg.calls] : unwrap ?? [],
+		creditAccount: existing?.creditAccount
+	};
+}
+/**
+* Quota a borrow buys for its collateral on an account that holds none yet.
+*
+* Shared with `maxBorrow`, because a quota short of the collateral's weighted
+* value is what caps the loan: the two have to read the same number or the
+* ceiling one offers is one the other refuses.
+*
+* @param props - {@link BorrowCollateralQuotaProps}
+**/
+function borrowCollateralQuota({ sdk, creditManager, assets, quotaReserve }) {
+	const suite = sdk.marketRegister.findCreditManager(creditManager);
+	const market = sdk.marketRegister.findByCreditManager(creditManager);
+	return getQuotasForUpdate({
+		assetsBefore: [],
+		assetsAfter: assets,
+		initialQuotas: [],
+		quotaReserve,
+		underlyingToken: market.pool.underlying,
+		liquidationThresholds: suite.creditManager.liquidationThresholds,
+		quotas: market.pool.pqk.quotas,
+		maxDebt: suite.creditFacade.maxDebt,
+		convert: (from, to, amount) => market.priceOracle.safeConvert(from, to, amount).value
+	}).quotaIncrease;
+}
+//#endregion
+export { borrowCollateralQuota, buildBorrowState };

package/dist/esm/onchain/accounts/intents/collateral-valuation.js

@@ -0,0 +1,40 @@
+import { BigIntMath } from "../../utils/bigint-math.js";
+import { PERCENTAGE_FACTOR } from "../../constants/math.js";
+import "../../utils/index.js";
+import { eq } from "./utils/common.js";
+//#region src/onchain/accounts/intents/collateral-valuation.ts
+/** {@inheritDoc CollateralValuation} */
+function collateralValuation(creditAccount, sdk) {
+	const { market, creditManager } = sdk.marketRegister.findCreditManager(creditAccount.creditManager);
+	const { priceOracle } = market;
+	const { pqk } = market.pool;
+	const underlying = market.pool.underlying;
+	const masked = creditAccount.enabledTokensMask !== 0n;
+	const mainUsd = (token, amount) => {
+		try {
+			return priceOracle.convertToUSD(token, amount);
+		} catch {
+			return;
+		}
+	};
+	const lt = (token) => BigInt(creditManager.liquidationThresholds.get(token) ?? 0);
+	const checkedUsd = (holding) => eq(holding.token, underlying) ? mainUsd(holding.token, holding.balance) ?? 0n : priceOracle.safeConvertMinUSD(holding.token, holding.balance).value;
+	/** A quota is underlying-denominated, and a closed market backs nothing. */
+	const quotaValue = (holding) => pqk.hasActiveQuota(holding.token) ? (mainUsd(underlying, holding.quota) ?? 0n) * PERCENTAGE_FACTOR : 0n;
+	const weigh = (holding) => {
+		const weighted = checkedUsd(holding) * lt(holding.token);
+		if (holding.quota === 0n) return weighted;
+		return BigIntMath.min(quotaValue(holding), weighted);
+	};
+	return {
+		underlying,
+		counts: (holding) => holding.balance > 10n && (!masked || (holding.mask & creditAccount.enabledTokensMask) !== 0n),
+		weigh,
+		quotaValue,
+		mainUsd,
+		checkedUsd,
+		lt
+	};
+}
+//#endregion
+export { collateralValuation };

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

@@ -6,6 +6,7 @@ import { checkCreditManagerPaused } from "../../validation/checks/checkCreditMan
 import { checkForbiddenToken } from "../../validation/checks/checkForbiddenToken.js";
 import { checkMarketExpired } from "../../validation/checks/checkMarketExpired.js";
 import { checkQuotaLimit } from "../../validation/checks/checkQuotaLimit.js";
+import { checkReservePriceLimited } from "../../validation/checks/checkReservePriceLimited.js";
 import { raise } from "../../validation/raise.js";
 import "../../validation/index.js";
 import { eq } from "./utils/common.js";
@@ -111,13 +112,24 @@ function assertGrowthAllowed(args) {
 * whose reserve feed the SDK cannot read keeps its main price, so a plan can
 * still be refused on-chain after passing here.
 */
-function assertCollateralised(healthFactorBps, safePrices) {
+function assertCollateralised(healthFactorBps, safePrices, atSafePrices) {
 	const healthFactorThreshold = MIN_HEALTH_FACTOR_FACADE;
-	raise(checkCollateralised({
+	const errors = checkCollateralised({
 		healthFactor: healthFactorBps,
 		healthFactorThreshold,
 		safePrices
-	}), `the account would end at a health factor of ${healthFactorBps}, below ${healthFactorThreshold}`);
+	});
+	if (errors.length === 0) return;
+	if (safePrices && atSafePrices) {
+		const { atMainPrices, withdrawable } = atSafePrices();
+		raise(checkReservePriceLimited({
+			healthFactor: healthFactorBps,
+			atMainPrices,
+			healthFactorThreshold,
+			withdrawable
+		}), `the account covers its debt at ${atMainPrices} on the main feed and only ${healthFactorBps} at the reserve one, below ${healthFactorThreshold}`);
+	}
+	raise(errors, `the account would end at a health factor of ${healthFactorBps}, below ${healthFactorThreshold}`);
 }
 /**
 * A quota can only be raised as far as the market still has room for: past the

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

@@ -7,14 +7,16 @@ import { IntentPreviewError } from "../../validation/raise.js";
 import "../../validation/index.js";
 import { isPhantomToken } from "./utils/pick-token.js";
 import { assertMarketOperable } from "./guards.js";
+import { fetchCreditAccountSlice, toCreditAccountSlice } from "./utils/credit-account-slice.js";
+import { buildBorrowState } from "./borrow.js";
 import { calcLeverageBand } from "./leverage-band.js";
-import { maxProportionalWithdrawal } from "./math.js";
+import { maxBorrow } from "./maxBorrow.js";
 import { maxWithdrawCollateral } from "./maxWithdrawCollateral.js";
-import { fetchCreditAccountSlice, toCreditAccountSlice } from "./utils/credit-account-slice.js";
 import { buildOpenStrategyState } from "./open-strategy.js";
 import { planAddCollateral, planAdjustLeverage, planAdjustLeverageDelayed, planDeposit, planRepay, planWithdraw, planWithdrawAsset, planWithdrawDelayed } from "./plan.js";
-import { realize } from "./realize.js";
 import { accountView } from "./view.js";
+import { withdrawLimits } from "./withdraw-limits.js";
+import { realize } from "./realize.js";
 import { planTail, projectTail } from "./tail.js";
 //#region src/onchain/accounts/intents/index.ts
 /**
@@ -50,26 +52,29 @@ 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
-	* `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.
+	* partial withdrawal that keeps leverage, 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.
 	*
-	* Takes no target health factor, unlike {@link maxWithdrawCollateral}: a
-	* proportional withdrawal leaves the factor where it found it, and the
-	* facade's `minDebt` is what bounds it.
+	* Two rules bound the partial end and both are reported: the facade's
+	* `debtLimits` as `partial`, and the safe-price collateral check on top of
+	* it as `safePartial`. The second is the one to offer — see
+	* {@link WithdrawCeilings}.
 	*
-	* @param props - Account slice and the SDK holding its market
-	* @returns The two ceilings, see {@link WithdrawCeilings} for the gap between
-	* them
+	* Takes no target health factor, unlike {@link maxWithdrawCollateral}. A
+	* proportional withdrawal leaves the factor where it found it, so there is
+	* no room to choose: what these answer to is the facade's own threshold,
+	* which is also what {@link startIntent} refuses against.
+	*
+	* @param props - Account slice, the SDK holding its market, and optionally
+	* the collateral the withdrawal would be funded from
+	* @returns The three limits, see {@link WithdrawCeilings} for the gap
+	* between them
 	*/
 	maxWithdraw(props) {
-		const view = accountView(props.creditAccount, props.sdk);
-		return {
-			partial: maxProportionalWithdrawal(view, view.debtLimits),
-			exit: view.collateral > 0n ? view.collateral : 0n
-		};
+		return withdrawLimits(props);
 	}
 	/**
 	* Debt a `REPAY` would have to cover to settle the account, in underlying
@@ -129,6 +134,34 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 		});
 	}
 	/**
+	* Largest loan a given collateral supports at `targetHF`, in the payout
+	* token's units — the ceiling a borrow form should offer.
+	*
+	* Reads no account, like {@link leverageBand}: the borrow opens one. The
+	* collateral is valued the way the transaction will be judged, at safe
+	* prices and under the quota the borrow buys, and the answer is then held to
+	* what the market will lend.
+	*
+	* A ceiling, not a verdict: the facade's `minDebt` is a floor and is not
+	* applied here, so collateral too small for this market still answers with
+	* what it carries and {@link borrowIntent} is the one that refuses the loan.
+	*
+	* The default is {@link MIN_HF_LIMITED}, the threshold a form holds an
+	* account to.
+	*
+	* @param props - The manager, the SDK holding its market, the collateral put
+	* up, the token to be paid in, and optionally the health factor to land at
+	* @returns Amount in the payout token's units; `0n` where no loan of this
+	* shape can be funded at any size
+	*/
+	maxBorrow(props) {
+		const { targetHF = MIN_HF_LIMITED, ...rest } = props;
+		return maxBorrow({
+			...rest,
+			targetHF: targetHF + 2n
+		});
+	}
+	/**
 	* Previews the same operation when its source only redeems through its
 	* issuer: a Securitize dsToken, a Mellow share.
 	*
@@ -179,7 +212,10 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 			});
 			return {
 				...result,
-				state: tail.state,
+				state: {
+					...tail.state,
+					executionCost: result.state.executionCost
+				},
 				delayed
 			};
 		} catch (e) {
@@ -271,6 +307,26 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 		};
 	}
 	/**
+	* Previews opening an account that holds nothing.
+	*
+	* Nothing is put up, drawn or routed, so there is no state to build and no
+	* guard to run beyond the market's own: a paused or expired facade takes no
+	* multicall, and an opening is a multicall like any other. Answers the same
+	* envelope its two neighbours do so a caller branches on `ok` throughout.
+	*
+	* @param props - The SDK holding the market, and the manager to open in
+	* @returns `{ ok: true }`, or `{ ok: false, error }` when the market takes
+	* no transaction right now
+	*/
+	async openEmptyAccountIntent(props) {
+		try {
+			assertMarketOperable(props.sdk.marketRegister.findCreditManager(props.creditManager));
+			return { ok: true };
+		} catch (e) {
+			return asSDKError(e);
+		}
+	}
+	/**
 	* Previews opening a brand-new leveraged position.
 	*
 	* Sits apart from {@link startIntent} because there is no account yet: nothing
@@ -292,6 +348,37 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 			return asSDKError(e);
 		}
 	}
+	/**
+	* Previews taking a loan against collateral, on an account this same
+	* transaction opens.
+	*
+	* Sits beside {@link openStrategyIntent} rather than under
+	* {@link startIntent} for the same reason: there is no account yet, and the
+	* output feeds `sdk.accounts.openCA`. What sets it apart from an opening is
+	* where the loan goes — out to the wallet rather than into a position — so
+	* the debt is named outright instead of following from a leverage, and the
+	* collateral is the only thing the account is left holding.
+	*
+	* `creditAccount` draws the loan on one the wallet already holds instead of
+	* opening another, as an opening takes one.
+	*
+	* @param props - Credit manager, the collateral the wallet puts up and the
+	* payout it asks for
+	* @returns Debt, the payout's two branches and the projection the account
+	* lands in, or `{ ok: false, error }` when the loan is not viable — a debt
+	* outside the facade's limits, collateral that cannot carry it, a payout the
+	* router has no path to
+	*/
+	async borrowIntent(props) {
+		try {
+			return {
+				ok: true,
+				state: await buildBorrowState(props)
+			};
+		} catch (e) {
+			return asSDKError(e);
+		}
+	}
 	/** Plan → realise → wrap. Unviable requests become `{ ok: false }`. */
 	async #preview(props, plan) {
 		try {

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

@@ -1,5 +1,6 @@
 import { BigIntMath } from "../../utils/bigint-math.js";
 import { LEVERAGE_DECIMALS } from "../../constants/math.js";
+import { resolveCreditManager } from "./utils/common.js";
 //#region src/onchain/accounts/intents/leverage-band.ts
 /**
 * The leverages this market will actually fund for a position of this size.
@@ -29,7 +30,7 @@ import { LEVERAGE_DECIMALS } from "../../constants/math.js";
 * ```
 **/
 function calcLeverageBand({ sdk, creditManager, collateral, targetHF }) {
-	const found = resolve(sdk, creditManager);
+	const found = resolveCreditManager(sdk, creditManager);
 	if (!found) return;
 	const { suite, market } = found;
 	const target = suite.strategyTargetCollateral;
@@ -54,16 +55,5 @@ function calcLeverageBand({ sdk, creditManager, collateral, targetHF }) {
 		max
 	};
 }
-/** The manager's suite and market, or nothing while they cannot be resolved. */
-function resolve(sdk, creditManager) {
-	try {
-		return {
-			suite: sdk.marketRegister.findCreditManager(creditManager),
-			market: sdk.marketRegister.findByCreditManager(creditManager)
-		};
-	} catch {
-		return;
-	}
-}
 //#endregion
 export { calcLeverageBand };

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

@@ -0,0 +1,87 @@
+import { BigIntMath } from "../../utils/bigint-math.js";
+import "../../constants/math.js";
+import "../../utils/index.js";
+import { eq, resolveCreditManager, toTargetDecimals } from "./utils/common.js";
+import { unopenedAccountSlice } from "./utils/credit-account-slice.js";
+import "./utils/index.js";
+import { borrowCollateralQuota } from "./borrow.js";
+import { collateralValuation } from "./collateral-valuation.js";
+//#region src/onchain/accounts/intents/maxBorrow.ts
+/**
+* Largest loan this collateral supports at `targetHF` — the ceiling a borrow
+* form should offer, in the payout token's units.
+*
+* The inverse of a borrow rather than a search for one: the loan leaves the
+* account entirely, so the collateral is the whole of what backs the debt, and
+* the health factor is one division away from the amount. Solving it the other
+* way round costs a division too, and no iteration.
+*
+* Collateral is valued the way the transaction will be judged — at safe
+* prices, under its liquidation threshold, capped by the quota the borrow
+* buys for it, all of which is {@link collateralValuation}'s business. The ceiling
+* is then held to what the market will actually lend: the pool's free
+* liquidity, the manager's own allowance and the facade's `maxDebt`, whichever
+* binds first.
+*
+* The facade's `minDebt` is deliberately not applied. It is a floor, and a
+* ceiling answered as `0n` because the collateral is too small for this market
+* would tell a form nothing about what it is holding — the number a user needs
+* to see is the one they are short of. Collateral that carries something
+* therefore answers with it, whether or not the market would lend that little;
+* a loan under the floor is refused by `borrow` itself, with `debtOutOfRange`
+* naming both ends.
+*
+* Nothing is fetched or simulated — the account does not exist yet and every
+* input is loaded market state, so a form can call this on each keystroke.
+*
+* @param props - {@link MaxBorrowProps}
+* @returns Amount in the payout token's units; `0n` where no loan of this
+* shape exists at any size — a collateral that backs nothing at safe prices, a
+* market with nothing left to lend, and a manager the SDK does not hold yet
+**/
+function maxBorrow(props) {
+	const { sdk, creditManager, collateralAmount, targetHF, quotaReserve } = props;
+	const found = resolveCreditManager(sdk, creditManager);
+	if (!found) return 0n;
+	const { suite, market } = found;
+	const { priceOracle } = market;
+	const underlying = market.pool.underlying.toLowerCase();
+	const collateralToken = props.collateralToken.toLowerCase();
+	const borrowToken = props.borrowToken.toLowerCase();
+	const rwaAsset = sdk.tokensMeta.rwaUnderlyings.get(underlying)?.asset?.toLowerCase();
+	if (eq(collateralToken, borrowToken)) return 0n;
+	if (rwaAsset && eq(borrowToken, underlying)) return 0n;
+	if (collateralAmount <= 10n || targetHF <= 0n) return 0n;
+	const quotas = borrowCollateralQuota({
+		sdk,
+		creditManager,
+		assets: [{
+			token: collateralToken,
+			balance: collateralAmount
+		}],
+		quotaReserve
+	});
+	const holding = {
+		token: collateralToken,
+		balance: collateralAmount,
+		quota: quotas.find((q) => eq(q.token, collateralToken))?.balance ?? 0n,
+		mask: 0n,
+		success: true
+	};
+	const valuation = collateralValuation({
+		...unopenedAccountSlice({
+			creditManager,
+			creditFacade: suite.creditFacade.address,
+			underlying
+		}),
+		tokens: [holding]
+	}, sdk);
+	const weighted = valuation.checkedUsd(holding) * valuation.lt(collateralToken);
+	const backed = quotas.some((q) => eq(q.token, collateralToken)) ? BigIntMath.min(valuation.quotaValue(holding), weighted) : weighted;
+	if (backed <= 0n) return 0n;
+	const ceiling = BigIntMath.min(priceOracle.safeConvertFromUSD(underlying, backed / targetHF).value, suite.maxBorrowAmount().amount.value);
+	const unwrapsPayout = !!rwaAsset && eq(borrowToken, rwaAsset);
+	return eq(borrowToken, underlying) ? ceiling : unwrapsPayout ? toTargetDecimals(ceiling, underlying, borrowToken, sdk) : priceOracle.safeConvert(underlying, borrowToken, ceiling).value;
+}
+//#endregion
+export { maxBorrow };