@gearbox-protocol/sdk 16.3.2-next.1 → 16.3.2

package/dist/cjs/onchain/accounts/intents/withdraw-limits.js

@@ -1,97 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_onchain_utils_bigint_math = require("../../utils/bigint-math.js");
-require("../../utils/index.js");
-const require_onchain_validation_helpers_health_factor_limits = require("../../validation/helpers/health-factor-limits.js");
-require("../../validation/index.js");
-const require_onchain_accounts_intents_utils_common = require("./utils/common.js");
-const require_onchain_accounts_intents_collateral_money = require("./collateral-money.js");
-const require_onchain_accounts_intents_math = require("./math.js");
-const require_onchain_accounts_intents_view = require("./view.js");
-//#region src/onchain/accounts/intents/withdraw-limits.ts
-/**
-* Every limit a `WITHDRAW` answers to, in underlying units.
-*
-* The one place they are assembled, so the figure a form is offered and the
-* figure the collateral guard names when it turns a withdrawal down cannot
-* drift apart: `CreditAccountOperationsService` reports this, and the guard
-* quotes it back.
-*
-* @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}
-**/
-function withdrawLimits(props) {
-	const { creditAccount, sdk } = props;
-	const view = require_onchain_accounts_intents_view.accountView(creditAccount, sdk);
-	const partial = require_onchain_accounts_intents_math.maxProportionalWithdrawal(view, view.debtLimits);
-	const safe = maxSafeWithdrawal({
-		...props,
-		targetHF: BigInt(require_onchain_validation_helpers_health_factor_limits.MIN_HEALTH_FACTOR_FACADE)
-	});
-	return {
-		partial,
-		safePartial: require_onchain_utils_bigint_math.BigIntMath.min(partial, safe),
-		exit: view.collateral > 0n ? view.collateral : 0n
-	};
-}
-/**
-* Largest proportional withdrawal the safe-price collateral check still clears,
-* in underlying units.
-*
-* A withdrawal hands funds over, so the facade weighs the account it leaves
-* behind at safe prices rather than main ones — see {@link collateralMoney}.
-* That is a second limit on top of the facade's `debtLimits`, and the two are
-* independent: a caller wanting the amount a form may actually offer takes the
-* lesser of this and `maxProportionalWithdrawal`.
-*
-* The arithmetic is the check solved for the amount. Taking `W` out at fixed
-* leverage repays `dD = D·W/C`, so `W·TVL/C` of value is sold out of the source
-* token; each dollar of that sale costs the check the source's threshold times
-* its safe-to-main price ratio, while the repayment relieves `targetHF` per
-* dollar of debt. Both terms are linear in `W`, which is why one division
-* answers instead of a search — and why the answer is exact rather than a
-* bound, as long as the plan really does fund itself from `sourceToken`.
-*
-* Two consequences worth stating, because they surprise:
-*
-* - An account whose collateral is entirely a token the reserve feed marks
-*   down cannot withdraw at all once it is under the threshold. A proportional
-*   withdrawal scales collateral and debt together, so it leaves the safe-price
-*   factor exactly where it found it — no amount climbs back over.
-* - Leaving entirely is never refused for this reason: the exit settles the
-*   debt instead of shrinking it, and a check with no debt to divide by has
-*   nothing to refuse.
-*
-* @returns Amount in underlying units. The account's net value when safe prices
-* do not limit the withdrawal at all, so the caller's `min` is a no-op; `0n`
-* when the account already sits below `targetHF` at safe prices, and only the
-* exit is left
-**/
-function maxSafeWithdrawal(props) {
-	const { creditAccount, sdk, targetHF } = props;
-	const view = require_onchain_accounts_intents_view.accountView(creditAccount, sdk);
-	if (view.collateral <= 0n) return 0n;
-	if (view.debt === 0n) return view.collateral;
-	const money = require_onchain_accounts_intents_collateral_money.collateralMoney(creditAccount, sdk);
-	const source = props.sourceToken ?? view.fattest();
-	const holding = source === void 0 ? void 0 : creditAccount.tokens.find((t) => require_onchain_accounts_intents_utils_common.eq(t.token, source));
-	if (!holding) return view.collateral;
-	let total = 0n;
-	for (const t of creditAccount.tokens) if (money.counts(t)) total += money.weigh(t);
-	const debtUsd = money.mainUsd(money.underlying, view.debt);
-	if (debtUsd === void 0 || debtUsd <= 0n) return view.collateral;
-	const slack = total - debtUsd * targetHF;
-	if (slack < 0n) return 0n;
-	const sourceMainUsd = money.mainUsd(holding.token, holding.balance);
-	if (sourceMainUsd === void 0 || sourceMainUsd <= 0n) return view.collateral;
-	const sourceRate = money.lt(holding.token) * money.checkedUsd(holding);
-	const tvlUsd = money.mainUsd(money.underlying, view.collateral + view.debt);
-	if (tvlUsd === void 0) return view.collateral;
-	const drain = sourceRate * tvlUsd - targetHF * debtUsd * sourceMainUsd;
-	if (drain <= 0n) return view.collateral;
-	const limit = view.collateral * slack * sourceMainUsd / drain;
-	return limit < view.collateral ? limit : view.collateral;
-}
-//#endregion
-exports.maxSafeWithdrawal = maxSafeWithdrawal;
-exports.withdrawLimits = withdrawLimits;

package/dist/cjs/onchain/validation/checks/checkReservePriceLimited.js

@@ -1,30 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_model_errors_operation_errors = require("../../../model/errors/operation-errors.js");
-require("../../../model/index.js");
-//#region src/onchain/validation/checks/checkReservePriceLimited.ts
-/**
-* Whether a failed collateral check is the reserve price feed's doing.
-*
-* A call that hands funds over is weighed at safe prices — `min` of a token's
-* two feeds, and nothing at all where governance registered no reserve feed —
-* so an account that covers its debt at the main feed can still be refused.
-* The two are worth telling apart: a position that is genuinely too small is
-* fixed by adding collateral or requesting less, while this one is a valuation
-* the account does not control, and requesting less only helps as far as
-* `withdrawable` says it does.
-*
-* Runs after `checkCollateralised` and answers only when that one refused, so
-* the caller keeps its own threshold rather than restating it here.
-*/
-function checkReservePriceLimited(args) {
-	const { healthFactor, atMainPrices, healthFactorThreshold, withdrawable } = args;
-	if (healthFactor >= healthFactorThreshold || atMainPrices < healthFactorThreshold) return [];
-	return [require_model_errors_operation_errors.reservePriceLimited({
-		healthFactor,
-		atMainPrices,
-		healthFactorThreshold,
-		withdrawable
-	})];
-}
-//#endregion
-exports.checkReservePriceLimited = checkReservePriceLimited;

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

@@ -1,40 +0,0 @@
-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-money.ts
-/** {@inheritDoc CollateralMoney} */
-function collateralMoney(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 quotaMoney = (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(quotaMoney(holding), weighted);
-	};
-	return {
-		underlying,
-		counts: (holding) => holding.balance > 10n && (!masked || (holding.mask & creditAccount.enabledTokensMask) !== 0n),
-		weigh,
-		quotaMoney,
-		mainUsd,
-		checkedUsd,
-		lt
-	};
-}
-//#endregion
-export { collateralMoney };

package/dist/esm/onchain/accounts/intents/withdraw-limits.js

@@ -1,95 +0,0 @@
-import { BigIntMath } from "../../utils/bigint-math.js";
-import "../../utils/index.js";
-import { MIN_HEALTH_FACTOR_FACADE } from "../../validation/helpers/health-factor-limits.js";
-import "../../validation/index.js";
-import { eq } from "./utils/common.js";
-import { collateralMoney } from "./collateral-money.js";
-import { maxProportionalWithdrawal } from "./math.js";
-import { accountView } from "./view.js";
-//#region src/onchain/accounts/intents/withdraw-limits.ts
-/**
-* Every limit a `WITHDRAW` answers to, in underlying units.
-*
-* The one place they are assembled, so the figure a form is offered and the
-* figure the collateral guard names when it turns a withdrawal down cannot
-* drift apart: `CreditAccountOperationsService` reports this, and the guard
-* quotes it back.
-*
-* @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}
-**/
-function withdrawLimits(props) {
-	const { creditAccount, sdk } = props;
-	const view = accountView(creditAccount, sdk);
-	const partial = maxProportionalWithdrawal(view, view.debtLimits);
-	const safe = maxSafeWithdrawal({
-		...props,
-		targetHF: BigInt(MIN_HEALTH_FACTOR_FACADE)
-	});
-	return {
-		partial,
-		safePartial: BigIntMath.min(partial, safe),
-		exit: view.collateral > 0n ? view.collateral : 0n
-	};
-}
-/**
-* Largest proportional withdrawal the safe-price collateral check still clears,
-* in underlying units.
-*
-* A withdrawal hands funds over, so the facade weighs the account it leaves
-* behind at safe prices rather than main ones — see {@link collateralMoney}.
-* That is a second limit on top of the facade's `debtLimits`, and the two are
-* independent: a caller wanting the amount a form may actually offer takes the
-* lesser of this and `maxProportionalWithdrawal`.
-*
-* The arithmetic is the check solved for the amount. Taking `W` out at fixed
-* leverage repays `dD = D·W/C`, so `W·TVL/C` of value is sold out of the source
-* token; each dollar of that sale costs the check the source's threshold times
-* its safe-to-main price ratio, while the repayment relieves `targetHF` per
-* dollar of debt. Both terms are linear in `W`, which is why one division
-* answers instead of a search — and why the answer is exact rather than a
-* bound, as long as the plan really does fund itself from `sourceToken`.
-*
-* Two consequences worth stating, because they surprise:
-*
-* - An account whose collateral is entirely a token the reserve feed marks
-*   down cannot withdraw at all once it is under the threshold. A proportional
-*   withdrawal scales collateral and debt together, so it leaves the safe-price
-*   factor exactly where it found it — no amount climbs back over.
-* - Leaving entirely is never refused for this reason: the exit settles the
-*   debt instead of shrinking it, and a check with no debt to divide by has
-*   nothing to refuse.
-*
-* @returns Amount in underlying units. The account's net value when safe prices
-* do not limit the withdrawal at all, so the caller's `min` is a no-op; `0n`
-* when the account already sits below `targetHF` at safe prices, and only the
-* exit is left
-**/
-function maxSafeWithdrawal(props) {
-	const { creditAccount, sdk, targetHF } = props;
-	const view = accountView(creditAccount, sdk);
-	if (view.collateral <= 0n) return 0n;
-	if (view.debt === 0n) return view.collateral;
-	const money = collateralMoney(creditAccount, sdk);
-	const source = props.sourceToken ?? view.fattest();
-	const holding = source === void 0 ? void 0 : creditAccount.tokens.find((t) => eq(t.token, source));
-	if (!holding) return view.collateral;
-	let total = 0n;
-	for (const t of creditAccount.tokens) if (money.counts(t)) total += money.weigh(t);
-	const debtUsd = money.mainUsd(money.underlying, view.debt);
-	if (debtUsd === void 0 || debtUsd <= 0n) return view.collateral;
-	const slack = total - debtUsd * targetHF;
-	if (slack < 0n) return 0n;
-	const sourceMainUsd = money.mainUsd(holding.token, holding.balance);
-	if (sourceMainUsd === void 0 || sourceMainUsd <= 0n) return view.collateral;
-	const sourceRate = money.lt(holding.token) * money.checkedUsd(holding);
-	const tvlUsd = money.mainUsd(money.underlying, view.collateral + view.debt);
-	if (tvlUsd === void 0) return view.collateral;
-	const drain = sourceRate * tvlUsd - targetHF * debtUsd * sourceMainUsd;
-	if (drain <= 0n) return view.collateral;
-	const limit = view.collateral * slack * sourceMainUsd / drain;
-	return limit < view.collateral ? limit : view.collateral;
-}
-//#endregion
-export { maxSafeWithdrawal, withdrawLimits };

package/dist/esm/onchain/validation/checks/checkReservePriceLimited.js

@@ -1,29 +0,0 @@
-import { reservePriceLimited } from "../../../model/errors/operation-errors.js";
-import "../../../model/index.js";
-//#region src/onchain/validation/checks/checkReservePriceLimited.ts
-/**
-* Whether a failed collateral check is the reserve price feed's doing.
-*
-* A call that hands funds over is weighed at safe prices — `min` of a token's
-* two feeds, and nothing at all where governance registered no reserve feed —
-* so an account that covers its debt at the main feed can still be refused.
-* The two are worth telling apart: a position that is genuinely too small is
-* fixed by adding collateral or requesting less, while this one is a valuation
-* the account does not control, and requesting less only helps as far as
-* `withdrawable` says it does.
-*
-* Runs after `checkCollateralised` and answers only when that one refused, so
-* the caller keeps its own threshold rather than restating it here.
-*/
-function checkReservePriceLimited(args) {
-	const { healthFactor, atMainPrices, healthFactorThreshold, withdrawable } = args;
-	if (healthFactor >= healthFactorThreshold || atMainPrices < healthFactorThreshold) return [];
-	return [reservePriceLimited({
-		healthFactor,
-		atMainPrices,
-		healthFactorThreshold,
-		withdrawable
-	})];
-}
-//#endregion
-export { checkReservePriceLimited };

package/dist/types/onchain/accounts/intents/collateral-money.d.ts

@@ -1,42 +0,0 @@
-import { OnchainSDK } from "../../OnchainSDK.js";
-import { CreditAccountSlice } from "./types.js";
-import "../../index.js";
-import { Address } from "viem";
-//#region src/onchain/accounts/intents/collateral-money.d.ts
-/** One balance on the account, as the slice carries it. */
-type Holding = CreditAccountSlice["tokens"][number];
-/**
- * The collateral check's own valuation of an account, as a handful of lookups.
- *
- * Shared by everything that solves that check for an amount, so the rules it
- * encodes are written once: a holding backed by a quota counts the lesser of the
- * quota and its threshold-weighted value, an unquoted one its weighted value
- * alone, and dust or a disabled balance nothing at all. Collateral is valued at
- * the protocol safe price — `min` of the two feeds, 0 where there is no reserve
- * — the way the facade values a call that hands funds over; the underlying is
- * exempt and stays on the main feed, as `CreditManagerV3._safeConvertToUSD`
- * does.
- *
- * Money is carried in USD × `PERCENTAGE_FACTOR`, the units the check compares
- * in, so a threshold never has to be divided back out.
- */
-interface CollateralMoney {
-  /** Market underlying, the one token safe pricing does not touch. */
-  underlying: Address;
-  /** Whether the holding is weighed at all. */
-  counts(holding: Holding): boolean;
-  /** What the holding backs, in USD × `PERCENTAGE_FACTOR`. */
-  weigh(holding: Holding): bigint;
-  /** What the holding's quota backs, in the same units; 0 on a closed market. */
-  quotaMoney(holding: Holding): bigint;
-  /** USD at the main feed; `undefined` when the token has no price at all. */
-  mainUsd(token: Address, amount: bigint): bigint | undefined;
-  /** USD the check counts the holding at, before its threshold. */
-  checkedUsd(holding: Holding): bigint;
-  /** Liquidation threshold in basis points; 0 for a token the manager refuses. */
-  lt(token: Address): bigint;
-}
-/** {@inheritDoc CollateralMoney} */
-declare function collateralMoney(creditAccount: CreditAccountSlice, sdk: OnchainSDK): CollateralMoney;
-//#endregion
-export { CollateralMoney, Holding, collateralMoney };

package/dist/types/onchain/accounts/intents/withdraw-limits.d.ts

@@ -1,80 +0,0 @@
-import { OnchainSDK } from "../../OnchainSDK.js";
-import { CreditAccountSlice, WithdrawCeilings } from "./types.js";
-import "../../index.js";
-import { Address } from "viem";
-//#region src/onchain/accounts/intents/withdraw-limits.d.ts
-interface WithdrawLimitsProps {
-  creditAccount: CreditAccountSlice;
-  sdk: OnchainSDK;
-  /**
-   * Token the withdrawal liquidates. Defaults to the account's largest
-   * non-phantom balance, which is what the planner reaches for when the intent
-   * names none.
-   */
-  sourceToken?: Address;
-}
-/**
- * Every limit a `WITHDRAW` answers to, in underlying units.
- *
- * The one place they are assembled, so the figure a form is offered and the
- * figure the collateral guard names when it turns a withdrawal down cannot
- * drift apart: `CreditAccountOperationsService` reports this, and the guard
- * quotes it back.
- *
- * @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}
- **/
-declare function withdrawLimits(props: WithdrawLimitsProps): WithdrawCeilings;
-interface MaxSafeWithdrawalProps {
-  creditAccount: CreditAccountSlice;
-  sdk: OnchainSDK;
-  /**
-   * Token the withdrawal liquidates. Defaults to the account's largest
-   * non-phantom balance, which is what the planner reaches for when the intent
-   * names none.
-   */
-  sourceToken?: Address;
-  /**
-   * Health factor the withdrawal has to leave behind, in basis points. The
-   * facade's own threshold answers "would this land"; a form holding the
-   * account to something stricter passes its own.
-   */
-  targetHF: bigint;
-}
-/**
- * Largest proportional withdrawal the safe-price collateral check still clears,
- * in underlying units.
- *
- * A withdrawal hands funds over, so the facade weighs the account it leaves
- * behind at safe prices rather than main ones — see {@link collateralMoney}.
- * That is a second limit on top of the facade's `debtLimits`, and the two are
- * independent: a caller wanting the amount a form may actually offer takes the
- * lesser of this and `maxProportionalWithdrawal`.
- *
- * The arithmetic is the check solved for the amount. Taking `W` out at fixed
- * leverage repays `dD = D·W/C`, so `W·TVL/C` of value is sold out of the source
- * token; each dollar of that sale costs the check the source's threshold times
- * its safe-to-main price ratio, while the repayment relieves `targetHF` per
- * dollar of debt. Both terms are linear in `W`, which is why one division
- * answers instead of a search — and why the answer is exact rather than a
- * bound, as long as the plan really does fund itself from `sourceToken`.
- *
- * Two consequences worth stating, because they surprise:
- *
- * - An account whose collateral is entirely a token the reserve feed marks
- *   down cannot withdraw at all once it is under the threshold. A proportional
- *   withdrawal scales collateral and debt together, so it leaves the safe-price
- *   factor exactly where it found it — no amount climbs back over.
- * - Leaving entirely is never refused for this reason: the exit settles the
- *   debt instead of shrinking it, and a check with no debt to divide by has
- *   nothing to refuse.
- *
- * @returns Amount in underlying units. The account's net value when safe prices
- * do not limit the withdrawal at all, so the caller's `min` is a no-op; `0n`
- * when the account already sits below `targetHF` at safe prices, and only the
- * exit is left
- **/
-declare function maxSafeWithdrawal(props: MaxSafeWithdrawalProps): bigint;
-//#endregion
-export { MaxSafeWithdrawalProps, WithdrawLimitsProps, maxSafeWithdrawal, withdrawLimits };

package/dist/types/onchain/validation/checks/checkReservePriceLimited.d.ts

@@ -1,31 +0,0 @@
-import { Bps, TokenAmount } from "../../../model/primitives.js";
-import { ReservePriceLimitedError } from "../../../model/errors/operation-errors.js";
-import "../../../model/index.js";
-//#region src/onchain/validation/checks/checkReservePriceLimited.d.ts
-interface ReservePriceLimitedArgs {
-  /** The safe-price factor, the one the collateral check compared. */
-  healthFactor: Bps;
-  /** The same account at the main feed. */
-  atMainPrices: Bps;
-  /** The lowest acceptable factor — a factor equal to it passes. */
-  healthFactorThreshold: Bps;
-  /** What the account can still take out, in the market's underlying. */
-  withdrawable: TokenAmount;
-}
-/**
- * Whether a failed collateral check is the reserve price feed's doing.
- *
- * A call that hands funds over is weighed at safe prices — `min` of a token's
- * two feeds, and nothing at all where governance registered no reserve feed —
- * so an account that covers its debt at the main feed can still be refused.
- * The two are worth telling apart: a position that is genuinely too small is
- * fixed by adding collateral or requesting less, while this one is a valuation
- * the account does not control, and requesting less only helps as far as
- * `withdrawable` says it does.
- *
- * Runs after `checkCollateralised` and answers only when that one refused, so
- * the caller keeps its own threshold rather than restating it here.
- */
-declare function checkReservePriceLimited(args: ReservePriceLimitedArgs): ReservePriceLimitedError[];
-//#endregion
-export { ReservePriceLimitedArgs, checkReservePriceLimited };