@gearbox-protocol/sdk 17.2.0 → 17.3.0

package/dist/esm/rewards/{multichain.js → RewardsService.js}

@@ -3,11 +3,23 @@ import "../onchain/index.js";
 import { fetchMerklUserRewards } from "./merkl-api.js";
 import { toMerklRewards } from "./toMerklRewards.js";
 import { toTurtleRewards } from "./toTurtleRewards.js";
-import { fetchTurtleWalletRewards, turtleStreamAbi } from "./turtle-api.js";
+import { fetchTurtleWalletRewards, readTurtleClaimed } from "./turtle-api.js";
 import { getAddress } from "viem";
-//#region src/rewards/multichain.ts
-var RewardsFanOut = class extends MultichainConstruct {
-	async list({ wallet, chainIds, merklApiKey, turtleApiKey }) {
+//#region src/rewards/RewardsService.ts
+var RewardsService = class extends MultichainConstruct {
+	#keys;
+	constructor(sdk, keys = {}) {
+		super(sdk);
+		this.#keys = keys;
+	}
+	/**
+	* Every claimable reward a wallet holds — Merkl campaigns and the Gearbox
+	* organisation's Turtle streams — across the chains the handle carries.
+	* A chain is `status: "error"` only when every source failed on it; a chain
+	* with nothing to claim is a `"success"` with no rewards.
+	**/
+	async list(wallet, chainIds) {
+		const { merklApiKey, turtleApiKey } = this.#keys;
 		const user = getAddress(wallet);
 		const turtle = turtleApiKey ? fetchTurtleWalletRewards(user, turtleApiKey) : void 0;
 		turtle?.catch(() => {});
@@ -15,13 +27,13 @@ var RewardsFanOut = class extends MultichainConstruct {
 			chainIds,
 			label: "list rewards",
 			block: "state",
-			run: async (sdk, block) => {
+			run: async (sdk) => {
 				const sources = [fetchMerklUserRewards({
 					chainId: sdk.chainId,
 					user,
 					apiKey: merklApiKey
 				}).then((response) => toMerklRewards(sdk, response))];
-				if (turtle) sources.push(turtle.then(async (rewards) => toTurtleRewards(sdk, rewards, await readClaimed(sdk, user, rewards, block.blockNumber))));
+				if (turtle) sources.push(turtle.then(async (rewards) => toTurtleRewards(sdk, rewards, await readTurtleClaimed(sdk, user, rewards))));
 				const settled = await Promise.allSettled(sources);
 				const failed = settled.flatMap((r) => r.status === "rejected" ? [r.reason] : []);
 				if (failed.length === settled.length) throw failed.length === 1 ? failed[0] : new AggregateError(failed, "no rewards source answered");
@@ -31,29 +43,5 @@ var RewardsFanOut = class extends MultichainConstruct {
 		});
 	}
 };
-async function readClaimed(sdk, user, { proofs }, blockNumber) {
-	const onChain = proofs.filter((p) => p.chainId === sdk.chainId);
-	if (onChain.length === 0) return /* @__PURE__ */ new Map();
-	const claimed = await sdk.client.multicall({
-		contracts: onChain.map((p) => ({
-			address: p.contractAddress,
-			abi: turtleStreamAbi,
-			functionName: "getClaimedRewards",
-			args: [user]
-		})),
-		allowFailure: false,
-		blockNumber
-	});
-	return new Map(onChain.map((p, i) => [p.streamId, claimed[i]]));
-}
-/**
-* Every claimable reward a wallet holds — Merkl campaigns and the Gearbox
-* organisation's Turtle streams — across the chains the handle carries.
-* A chain is `status: "error"` only when every source failed on it; a chain
-* with nothing to claim is a `"success"` with no rows.
-**/
-async function getRewardsMultichain({ sdk, ...props }) {
-	return new RewardsFanOut(sdk).list(props);
-}
 //#endregion
-export { getRewardsMultichain };
+export { RewardsService };

package/dist/esm/rewards/errors.js

@@ -1,7 +1,7 @@
 import { BaseError } from "viem";
 //#region src/rewards/errors.ts
 /**
-* Thrown when none of Merkl's domains answered for a chain.
+* Thrown when Merkl did not answer for a chain.
 *
 * Everything a reader needs is in the message: this error travels to consumers
 * inside a chain's {@link ChainFailed} metadata, where it is typed `unknown`
@@ -10,10 +10,10 @@ import { BaseError } from "viem";
 var MerklRequestFailedError = class extends BaseError {
 	name = "MerklRequestFailedError";
 	chainId;
-	constructor(chainId, path, attempts) {
+	constructor(chainId, path, cause) {
 		super(`Merkl could not be reached for chain ${chainId}.`, {
-			cause: attempts.find(([, c]) => c instanceof Error)?.[1],
-			metaMessages: attempts.map(([domain, cause]) => `${domain}${path} — ${describe(cause)}`)
+			cause: cause instanceof Error ? cause : void 0,
+			metaMessages: [`${path} — ${describe(cause)}`]
 		});
 		this.chainId = chainId;
 	}

package/dist/esm/rewards/helpers.js

@@ -0,0 +1,83 @@
+import { AddressMap } from "../onchain/utils/AddressMap.js";
+import { toBigInt } from "../onchain/utils/formatter.js";
+import "../onchain/index.js";
+import { formatUnits, isAddress } from "viem";
+//#region src/rewards/helpers.ts
+/**
+* The pool a source names, and its share token. A v3.1 pool is its own
+* ERC-4626 share token, so its address is the only token a campaign can name;
+* the `AddressMap` owns the casing a source writes it in.
+*/
+function resolvePool(sdk) {
+	const pools = AddressMap.fromMappedArray(sdk.marketRegister.pools.map(({ pool }) => pool.address), (address) => address);
+	return (address) => {
+		if (!address || !isAddress(address, { strict: false })) return void 0;
+		const pool = pools.get(address);
+		const poolToken = pool && sdk.tokensMeta.getToken(pool);
+		return pool && poolToken ? {
+			pool,
+			poolToken
+		} : void 0;
+	};
+}
+/** Sources send amounts as free-form strings, which `toBigInt` throws on. */
+function parseAmount(value) {
+	if (value === void 0) return void 0;
+	try {
+		return toBigInt(value || 0);
+	} catch {
+		return;
+	}
+}
+/** What is left of `total` after `claimed`, when anything is. */
+function remaining(total, claimed) {
+	if (total === void 0 || claimed === void 0) return void 0;
+	return total > claimed ? total - claimed : void 0;
+}
+/**
+* An incentive token is rarely protocol collateral, so the registry usually
+* has no entry for it — and both sources always name it.
+*/
+function toRewardToken(sdk, address, named) {
+	return sdk.tokensMeta.getToken(address) ?? {
+		chainId: sdk.chainId,
+		address,
+		symbol: named.symbol,
+		name: named.name ?? named.symbol,
+		decimals: named.decimals || 18
+	};
+}
+/** A missing or unparsable price is `null`. */
+function toPricedAmount(token, value, price) {
+	const usd = Number(price ?? NaN);
+	return {
+		token,
+		value,
+		valueUsd: Number.isFinite(usd) ? Number(formatUnits(value, token.decimals)) * usd : null
+	};
+}
+/**
+* One reward per pool and incentive token, at the last part's price. Amounts
+* are summed raw and priced once at the end — pricing each part and adding the results would round
+* every one of them.
+*/
+function mergeRewards(sdk, source, parts) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const part of parts) {
+		const key = `${part.pool}_${part.token.address}`;
+		const seen = merged.get(key);
+		merged.set(key, seen ? {
+			...part,
+			value: seen.value + part.value
+		} : part);
+	}
+	return [...merged.values()].map(({ pool, poolToken, token, value, price }) => ({
+		source,
+		chainId: sdk.chainId,
+		pool,
+		poolToken,
+		amount: toPricedAmount(token, value, price)
+	}));
+}
+//#endregion
+export { mergeRewards, parseAmount, remaining, resolvePool, toRewardToken };

package/dist/esm/rewards/index.js

@@ -1,3 +1,3 @@
 import { MerklRequestFailedError, TurtleRequestFailedError } from "./errors.js";
-import { getRewardsMultichain } from "./multichain.js";
-export { MerklRequestFailedError, TurtleRequestFailedError, getRewardsMultichain };
+import { RewardsService } from "./RewardsService.js";
+export { MerklRequestFailedError, RewardsService, TurtleRequestFailedError };

package/dist/esm/rewards/merkl-api.js

@@ -1,42 +1,32 @@
 import { MerklRequestFailedError } from "./errors.js";
 //#region src/rewards/merkl-api.ts
-/**
-* Merkl's own host and the Angle mirror, tried in this order.
-*/
-const MERKL_DOMAINS = ["https://api.merkl.xyz", "https://api-merkl.angle.money"];
+const MERKL_API_URL = "https://api.merkl.xyz";
 const MERKL_API_KEY_HEADER = "X-API-Key";
 /**
-* Per-attempt budget. Merkl has no timeout of its own, and a hung connection
-* would otherwise stall its leg of a fan-out for as long as the socket lives.
+* Merkl has no timeout of its own, and a hung connection would otherwise stall
+* its leg of a fan-out for as long as the socket lives.
 */
-const ATTEMPT_TIMEOUT = 1e4;
+const TIMEOUT = 1e4;
 /**
 * The wallet's raw Merkl rewards on one chain.
 *
-* Rejects with {@link MerklRequestFailedError} when neither domain answers, so
-* a caller can tell an unreachable Merkl from a wallet with nothing to claim.
-* A non-2xx counts as no answer and moves to the next domain: it carries no
-* rewards either way, and treating it as success would report emptiness that
-* was never established.
+* Rejects with {@link MerklRequestFailedError} when Merkl does not answer, so a
+* caller can tell an unreachable Merkl from a wallet with nothing to claim. A
+* non-2xx counts as no answer: it carries no rewards either way, and treating
+* it as success would report emptiness that was never established.
 */
 async function fetchMerklUserRewards({ chainId, user, apiKey }) {
 	const path = `/v4/users/${user}/rewards?chainId=${chainId}`;
-	const headers = apiKey ? { [MERKL_API_KEY_HEADER]: apiKey } : void 0;
-	const attempts = [];
-	for (const domain of MERKL_DOMAINS) try {
-		const response = await fetch(`${domain}${path}`, {
-			headers,
-			signal: AbortSignal.timeout(ATTEMPT_TIMEOUT)
+	try {
+		const response = await fetch(`${MERKL_API_URL}${path}`, {
+			headers: apiKey ? { [MERKL_API_KEY_HEADER]: apiKey } : void 0,
+			signal: AbortSignal.timeout(TIMEOUT)
 		});
-		if (!response.ok) {
-			attempts.push([domain, /* @__PURE__ */ new Error(`answered ${response.status}`)]);
-			continue;
-		}
+		if (!response.ok) throw new Error(`answered ${response.status}`);
 		return await response.json();
 	} catch (error) {
-		attempts.push([domain, error]);
+		throw new MerklRequestFailedError(chainId, path, error);
 	}
-	throw new MerklRequestFailedError(chainId, path, attempts);
 }
 //#endregion
-export { MERKL_API_KEY_HEADER, MERKL_DOMAINS, fetchMerklUserRewards };
+export { MERKL_API_KEY_HEADER, fetchMerklUserRewards };

package/dist/esm/rewards/toMerklRewards.js

@@ -1,84 +1,29 @@
-import { AddressMap } from "../onchain/utils/AddressMap.js";
-import { BigIntMath } from "../onchain/utils/bigint-math.js";
-import { toBigInt } from "../onchain/utils/formatter.js";
-import "../onchain/index.js";
-import { formatUnits, getAddress, isAddress } from "viem";
+import { mergeRewards, parseAmount, remaining, resolvePool, toRewardToken } from "./helpers.js";
+import { getAddress, isAddress } from "viem";
 //#region src/rewards/toMerklRewards.ts
 /**
-* Merkl's answer for one chain, turned into rows of the read model.
+* Merkl's answer for one chain, one reward per pool and incentive token.
+* A breakdown Merkl cannot be read from is skipped rather than thrown on: it
+* must not sink the chain, which the caller would then be told is unreachable.
 */
 function toMerklRewards(sdk, response) {
-	const poolByItsToken = AddressMap.fromMappedArray(sdk.marketRegister.pools.map(({ pool }) => pool.address), (address) => address);
-	const claimable = /* @__PURE__ */ new Map();
-	for (const chainRewards of response) for (const reward of chainRewards.rewards) {
-		if (!isAddress(reward.token.address, { strict: false })) continue;
-		const rewardTokenAddress = getAddress(reward.token.address);
-		for (const reason of reward.breakdowns) {
-			const poolTokenAddress = (reason.reason || "").split("_").find((part) => part.startsWith("0x")) ?? "";
-			if (!isAddress(poolTokenAddress, { strict: false })) continue;
-			const pool = poolByItsToken.get(poolTokenAddress);
-			if (!pool) continue;
-			const amounts = toAmounts(reason);
-			if (!amounts) continue;
-			const amount = BigIntMath.max(amounts.total - amounts.claimed, 0n);
-			if (amount === 0n) continue;
-			const key = `${pool}_${rewardTokenAddress}`;
-			const seen = claimable.get(key);
-			if (seen) {
-				seen.value += amount;
-				continue;
-			}
-			const poolToken = sdk.tokensMeta.getToken(pool);
-			if (!poolToken) continue;
-			claimable.set(key, {
-				chainId: sdk.chainId,
-				pool,
-				poolToken,
-				token: toRewardToken(sdk, rewardTokenAddress, reward.token),
-				value: amount,
-				price: reward.token.price
-			});
-		}
-	}
-	return [...claimable.values()].map(toReward);
-}
-/**
-* `toBigInt` throws on anything `BigInt()` cannot parse, and Merkl's amounts
-* are free-form strings.
-*/
-function toAmounts(reason) {
-	try {
-		return {
-			total: toBigInt(reason.amount || 0),
-			claimed: toBigInt(reason.claimed || 0)
-		};
-	} catch {
-		return;
-	}
-}
-function toReward({ price, token, value, ...rest }) {
-	return {
-		...rest,
-		source: "merkl",
-		amount: {
-			token,
-			value,
-			valueUsd: price === void 0 ? null : Number(formatUnits(value, token.decimals)) * price
-		}
-	};
-}
-/**
-* An incentive token is rarely protocol collateral, so the registry usually
-* has no entry for it — and both sources always name it.
-*/
-function toRewardToken(sdk, address, named) {
-	return sdk.tokensMeta.getToken(address) ?? {
-		chainId: sdk.chainId,
-		address,
-		symbol: named.symbol,
-		name: named.name ?? named.symbol,
-		decimals: named.decimals || 18
-	};
+	const poolOf = resolvePool(sdk);
+	const parts = response.flatMap(({ rewards }) => rewards).flatMap(({ token, breakdowns }) => {
+		if (!isAddress(token.address, { strict: false })) return [];
+		const rewardToken = toRewardToken(sdk, getAddress(token.address), token);
+		return breakdowns.flatMap(({ reason, amount, claimed }) => {
+			const pool = poolOf(reason?.split("_").find((p) => p.startsWith("0x")));
+			const value = remaining(parseAmount(amount), parseAmount(claimed));
+			if (!pool || !value) return [];
+			return [{
+				...pool,
+				token: rewardToken,
+				value,
+				price: token.price
+			}];
+		});
+	});
+	return mergeRewards(sdk, "merkl", parts);
 }
 //#endregion
-export { toMerklRewards, toRewardToken };
+export { toMerklRewards };

package/dist/esm/rewards/toTurtleRewards.js

@@ -1,76 +1,60 @@
-import { AddressMap } from "../onchain/utils/AddressMap.js";
-import { BigIntMath } from "../onchain/utils/bigint-math.js";
-import { toBigInt } from "../onchain/utils/formatter.js";
-import "../onchain/index.js";
-import { toRewardToken } from "./toMerklRewards.js";
+import { mergeRewards, parseAmount, remaining, resolvePool, toRewardToken } from "./helpers.js";
 import { formatUnits, getAddress, isAddress } from "viem";
 //#region src/rewards/toTurtleRewards.ts
 /**
-* Rows for the streams targeting a pool on the SDK's chain, merged per pool
-* and incentive. A token row is what is committed and not yet claimed.
+* The streams targeting a pool on the SDK's chain, merged per pool and
+* incentive. A token reward is what is committed and not yet claimed.
 */
 function toTurtleRewards(sdk, { streams, proofs }, claimed) {
-	const pools = AddressMap.fromMappedArray(sdk.marketRegister.pools.map(({ pool }) => pool.address), (address) => address);
-	const proofByStream = new Map(proofs.map((p) => [p.streamId, p]));
-	const rows = /* @__PURE__ */ new Map();
-	for (const { streamId, snapshots, stream } of streams) {
-		const target = stream.customArgs.targetToken;
-		if (!target || Number(target.chain.chainId) !== sdk.chainId) continue;
-		if (!isAddress(target.address, { strict: false })) continue;
-		const pool = pools.get(target.address);
-		const poolToken = pool && sdk.tokensMeta.getToken(pool);
-		if (!pool || !poolToken) continue;
-		const base = {
+	const poolOf = resolvePool(sdk);
+	const committed = new Map(proofs.map((p) => [p.streamId, p.amount]));
+	const targeted = streams.flatMap((stream) => {
+		const target = stream.stream.customArgs.targetToken;
+		if (Number(target?.chain.chainId) !== sdk.chainId) return [];
+		const pool = poolOf(target?.address);
+		return pool ? [{
+			stream,
+			...pool
+		}] : [];
+	});
+	const tokens = targeted.flatMap(({ stream, pool, poolToken }) => {
+		const { point, rewardToken, lastSnapshot } = stream.stream;
+		if (point || !rewardToken || !isAddress(rewardToken.address, { strict: false })) return [];
+		const value = remaining(parseAmount(committed.get(stream.streamId)), claimed.get(stream.streamId));
+		if (!value) return [];
+		return [{
+			pool,
+			poolToken,
+			token: toRewardToken(sdk, getAddress(rewardToken.address), rewardToken),
+			value,
+			price: lastSnapshot?.rewardTokenPrice
+		}];
+	});
+	return [...mergeRewards(sdk, "turtle", tokens), ...toPoints(sdk, targeted)];
+}
+/** Points accrue per snapshot; the last one holds the running total. */
+function toPoints(sdk, targeted) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const { stream, pool, poolToken } of targeted) {
+		const { point } = stream.stream;
+		const raw = parseAmount(stream.snapshots.at(-1)?.rewardsAccumulated);
+		if (!point || !raw) continue;
+		const key = `${pool}_${point.id}`;
+		const value = (merged.get(key)?.points.value ?? 0) + Number(formatUnits(raw, point.decimals));
+		merged.set(key, {
 			source: "turtle",
 			chainId: sdk.chainId,
 			pool,
-			poolToken
-		};
-		const { point, rewardToken } = stream;
-		if (point) {
-			const value = parse(snapshots.at(-1)?.rewardsAccumulated);
-			if (!value) continue;
-			const key = `${pool}_${point.id}`;
-			const seen = rows.get(key);
-			rows.set(key, {
-				...base,
-				points: {
-					id: point.id,
-					name: point.name,
-					multiplier: null,
-					value: (seen?.points.value ?? 0) + Number(formatUnits(value, point.decimals))
-				}
-			});
-			continue;
-		}
-		if (!rewardToken || !isAddress(rewardToken.address, { strict: false })) continue;
-		const committed = parse(proofByStream.get(streamId)?.amount);
-		const done = claimed.get(streamId);
-		if (committed === void 0 || done === void 0) continue;
-		const value = BigIntMath.max(committed - done, 0n);
-		if (value === 0n) continue;
-		const token = toRewardToken(sdk, getAddress(rewardToken.address), rewardToken);
-		const key = `${pool}_${token.address}`;
-		const total = (rows.get(key)?.amount.value ?? 0n) + value;
-		const price = Number(stream.lastSnapshot?.rewardTokenPrice ?? NaN);
-		rows.set(key, {
-			...base,
-			amount: {
-				token,
-				value: total,
-				valueUsd: Number.isFinite(price) ? Number(formatUnits(total, token.decimals)) * price : null
+			poolToken,
+			points: {
+				id: point.id,
+				name: point.name,
+				multiplier: null,
+				value
 			}
 		});
 	}
-	return [...rows.values()];
-}
-function parse(amount) {
-	if (amount === void 0) return void 0;
-	try {
-		return toBigInt(amount);
-	} catch {
-		return;
-	}
+	return [...merged.values()];
 }
 //#endregion
 export { toTurtleRewards };

package/dist/esm/rewards/turtle-api.js

@@ -44,5 +44,21 @@ async function get(path, apiKey) {
 		throw new TurtleRequestFailedError(path, error);
 	}
 }
+/** What each of the wallet's streams on the chain has paid out, at the latest block. */
+async function readTurtleClaimed(sdk, user, { proofs }) {
+	const onChain = proofs.filter((p) => p.chainId === sdk.chainId);
+	if (onChain.length === 0) return /* @__PURE__ */ new Map();
+	const claimed = await sdk.client.multicall({
+		contracts: onChain.map((p) => ({
+			address: p.contractAddress,
+			abi: turtleStreamAbi,
+			functionName: "getClaimedRewards",
+			args: [user]
+		})),
+		allowFailure: false,
+		blockTag: "latest"
+	});
+	return new Map(onChain.map((p, i) => [p.streamId, claimed[i]]));
+}
 //#endregion
-export { fetchTurtleWalletRewards, turtleStreamAbi };
+export { fetchTurtleWalletRewards, readTurtleClaimed, turtleStreamAbi };

package/dist/esm/rewards/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/sdk/prepare/PrepareApi.js

@@ -230,7 +230,7 @@ var PrepareApi = class extends MultichainConstruct {
 			const sdk = await this.#chain(strategy.chainId);
 			const at = stateBlock(sdk);
 			Object.assign(state, marketOf(sdk, strategy.creditManager));
-			const targetToken = params.targetToken ?? sdk.marketRegister.findCreditManager(strategy.creditManager).strategyTargetCollateral;
+			const targetToken = params.targetToken ?? sdk.marketRegister.findCreditManager(strategy.creditManager).strategy?.targetCollateral;
 			if (!targetToken) return refused(noStrategyTargetCollateral(strategy.creditManager), state);
 			const reused = await reusable(sdk, strategy, params.creditAccount);
 			if (reused && "error" in reused) return refused(reused.error, state);

package/dist/types/model/errors/operation-errors.d.ts

@@ -11,11 +11,16 @@ import { Address } from "viem";
  * - `poolAvailableLiquidity` — the pool's available liquidity
  * - `managerDebtAvailable` — this credit manager's remaining debt allowance
  * - `maxDebt` — the facade's per-account `debtLimits.maxDebt`
+ * - `quotaAvailable` — remaining quota the market takes for the suite's
+ *   strategy target collateral (`limit - totalQuoted`, floored at 0); only an
+ *   account being opened is held to it
+ * - `minDebt` — every other limit left less than the facade's `minDebt`, so
+ *   no account can be opened; the amount is 0
  * - `debtPerBlockLimit` — facade takes no new debt this block; in practice
  *   `maxDebtPerBlockMultiplier == 0` after a with-loss liquidation
  * - `poolDebtLimit` — pool-wide debt cap; used on account-opening only
  **/
-type BorrowLimitCause = "poolAvailableLiquidity" | "managerDebtAvailable" | "maxDebt" | "debtPerBlockLimit" | "poolDebtLimit";
+type BorrowLimitCause = "poolAvailableLiquidity" | "managerDebtAvailable" | "maxDebt" | "quotaAvailable" | "minDebt" | "debtPerBlockLimit" | "poolDebtLimit";
 /**
  * The credit manager is paused and takes no multicall at all.
  **/

package/dist/types/onchain/accounts/intents/maxBorrow.d.ts

@@ -29,17 +29,19 @@ interface MaxBorrowProps {
  * 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.
+ * is then held to what the market will actually lend,
+ * {@link CreditSuite.maxBorrowAmount}: 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.
+ * The facade's `minDebt` is not applied to the collateral's own ceiling. 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. A market whose own capacity
+ * is under `minDebt` is different: the answer is `0n`, because no loan of any
+ * size exists there.
  *
  * 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.