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

package/dist/esm/preview/validate/checkOperation.js

@@ -1,183 +0,0 @@
-import { checkBorrowLimit, checkCollateralised, checkCreditManagerPaused, checkDebtInBand, checkForbiddenToken, checkFunding, checkMarketExpired, checkPoolPaused, checkPoolPayout, checkPoolSunset, checkPreviewError, checkQuotaCount, checkQuotaLimit } from "../../onchain/validation/checks.js";
-import { toToken } from "../../onchain/validation/token.js";
-import { borrowable } from "../../onchain/accounts/intents/guards.js";
-import "../../onchain/index.js";
-import { isAddressEqual } from "viem";
-//#region src/preview/validate/checkOperation.ts
-/**
-* Whether a parsed operation may be signed at all — the protocol state that
-* `checkPrerequisites` leaves out, since that one covers only what the sender
-* can fix themselves.
-*
-* Synchronous: the preview carries the numbers and the market is attached.
-* Reports the most fundamental issue it finds and stops there, which is the one
-* a caller acts on.
-*/
-function checkOperation(input, options = {}) {
-	const { sdk, preview } = input;
-	const malformed = checkPreviewError("warning" in preview ? preview.warning : void 0);
-	if (malformed) return malformed;
-	switch (preview.operation) {
-		case "Deposit":
-		case "Mint": return poolIssues(sdk, preview, options, true);
-		case "Withdraw":
-		case "Redeem": return poolIssues(sdk, preview, options, false);
-		case "DelayedCreditAccountOperation": return checkOperation({
-			sdk,
-			preview: preview.instantPreview
-		}, options);
-		case "OpenCreditAccount":
-		case "RWAOpenCreditAccount":
-		case "AdjustCreditAccount": return creditIssues(sdk, preview, options);
-		case "CloseCreditAccount":
-		case "RepayCreditAccount": return marketIssues(sdk.marketRegister.findCreditManager(preview.creditManager));
-	}
-}
-function poolIssues(sdk, preview, options, isDeposit) {
-	const market = sdk.marketRegister.findByPool(preview.pool);
-	return checkPoolPaused({
-		isPaused: market.pool.pool.isPaused,
-		pool: preview.pool
-	}) || checkPoolSunset({
-		isSunset: market.sunset,
-		isDeposit,
-		pool: preview.pool
-	}) || (isDeposit ? null : checkPoolPayout({
-		requested: preview.tokenOut.value,
-		available: market.pool.pool.availableLiquidity,
-		underlying: preview.tokenOut.token
-	})) || fundingIssue(options, [preview.tokenIn]);
-}
-/** What the market itself refuses, whatever the operation does. */
-function marketIssues(suite) {
-	const creditManager = suite.creditManager.address;
-	return checkCreditManagerPaused({
-		isPaused: suite.isPaused,
-		creditManager
-	}) || checkMarketExpired({
-		isExpired: suite.isExpired,
-		creditManager,
-		expirationDate: suite.creditFacade.expirationDate
-	});
-}
-function creditIssues(sdk, preview, options) {
-	const suite = sdk.marketRegister.findCreditManager(preview.creditManager);
-	const market = suite.market;
-	const underlying = toToken(sdk, market.pool.underlying);
-	const isOpening = preview.operation === "OpenCreditAccount" || preview.operation === "RWAOpenCreditAccount";
-	return marketIssues(suite) || checkDebtInBand({
-		debt: preview.totalDebt.value,
-		minDebt: suite.creditFacade.minDebt,
-		maxDebt: suite.creditFacade.maxDebt,
-		underlying,
-		allowZero: !isOpening
-	}) || borrowIssue(suite, preview, underlying) || forbiddenIssue(suite, preview) || quotaCountIssue(suite, preview) || quotaIssue(market, preview, underlying) || collateralIssue({
-		totalDebt: preview.totalDebt,
-		healthFactor: preview.estHealthFactor,
-		safeHealthFactor: preview.estSafeHealthFactor
-	}, options) || fundingIssue(options, preview.collateralAdded);
-}
-/**
-* A bar that reads nothing but the projected account, so a parsed transaction
-* and a simulated one are held to it by the same code.
-*
-* These stay separate functions rather than one block because the order the
-* checks run in is the answer: `checkOperation` interleaves the checks that
-* need an operation's *delta* between them, and the caller acts on the first
-* issue reported.
-*/
-function quotaCountIssue(suite, account) {
-	return checkQuotaCount({
-		count: account.quotas.filter((q) => q.value > 0n).length,
-		max: suite.creditManager.maxEnabledTokens
-	});
-}
-/**
-* What the transaction draws, against what the market can lend right now.
-*
-* Only a draw is weighed: repaying, or leaving the debt alone, can never exceed
-* a ceiling. Opening borrows the whole debt; adjusting borrows
-* `totalDebtChange`.
-*
-* The engine holds every simulation to this already (`assertCanBorrow`), so
-* this is here for the transactions it never saw — a pasted calldata reaches
-* the confirm screen with nothing else standing between it and a revert.
-*/
-function borrowIssue(suite, preview, underlying) {
-	const drawn = preview.operation === "AdjustCreditAccount" ? preview.totalDebtChange.value : preview.totalDebt.value;
-	if (drawn <= 0n) return null;
-	const { limit, binding } = borrowable(suite);
-	return checkBorrowLimit({
-		requested: drawn,
-		available: limit,
-		binding,
-		underlying
-	});
-}
-/**
-* The account against whichever bars the caller holds it to.
-*
-* A loan-free account is nothing to weigh: the health factor reports its
-* zero-debt sentinel and no bar applies.
-*
-* {@inheritDoc quotaCountIssue}
-*/
-function collateralIssue(account, options) {
-	const { minHealthFactor, minSafeHealthFactor, currentHealthFactor } = options;
-	if (account.totalDebt.value === 0n) return null;
-	return (minHealthFactor === void 0 ? null : checkCollateralised({
-		healthFactor: account.healthFactor,
-		required: minHealthFactor,
-		safePrices: false,
-		improvesFrom: currentHealthFactor
-	})) || (minSafeHealthFactor === void 0 ? null : checkCollateralised({
-		healthFactor: account.safeHealthFactor,
-		required: minSafeHealthFactor,
-		safePrices: true
-	}));
-}
-/** The wallet's side of the operation, against the balances it was given. */
-function fundingIssue(options, puts) {
-	const { balances } = options;
-	if (!balances) return null;
-	for (const { token, value } of puts) {
-		const issue = checkFunding({
-			token,
-			required: value,
-			held: balances.get(token.address) ?? 0n
-		});
-		if (issue) return issue;
-	}
-	return null;
-}
-function forbiddenIssue(suite, preview) {
-	const obtained = preview.operation === "AdjustCreditAccount" ? preview.assetsChange : preview.estAssets;
-	const forbidden = suite.forbiddenTokens;
-	for (const asset of obtained) {
-		if (asset.value <= 0n) continue;
-		const issue = checkForbiddenToken({
-			token: asset.token,
-			isForbidden: forbidden.some((f) => isAddressEqual(f, asset.token.address))
-		});
-		if (issue) return issue;
-	}
-	return null;
-}
-function quotaIssue(market, preview, underlying) {
-	const increases = preview.operation === "AdjustCreditAccount" ? preview.quotasChange : preview.quotas;
-	const { pqk } = market.pool;
-	for (const q of increases) {
-		if (q.value <= 0n) continue;
-		const quota = pqk.hasActiveQuota(q.token.address) ? pqk.quotas.get(q.token.address) : void 0;
-		const issue = checkQuotaLimit({
-			token: q.token,
-			requested: quota ? q.value : void 0,
-			available: (quota?.limit ?? 0n) - (quota?.totalQuoted ?? 0n),
-			underlying
-		});
-		if (issue) return issue;
-	}
-	return null;
-}
-//#endregion
-export { checkOperation, collateralIssue, marketIssues, quotaCountIssue };

package/dist/esm/preview/validate/checkSimulation.js

@@ -1,38 +0,0 @@
-import { checkDebtInBand } from "../../onchain/validation/checks.js";
-import { toToken } from "../../onchain/validation/token.js";
-import "../../onchain/index.js";
-import { collateralIssue, marketIssues, quotaCountIssue } from "./checkOperation.js";
-//#region src/preview/validate/checkSimulation.ts
-/**
-* Whether a simulated operation clears the caller's own bars.
-*
-* The engine holds an account to the facade's `1.0`, because its guards answer
-* "would this revert". A form is wiser to ask for more, and the engine's own
-* note says so — a caller wanting the stricter bar applies it itself. This is
-* that second opinion, over the numbers the engine already reported.
-*
-* Three of the checks below the engine does not make at all: both health-factor
-* bars are its own `1.0`, and the quota count it never weighs. The other two run
-* against the same numbers the engine used, and are here so that a change in the
-* engine cannot pass silently.
-*
-* What is deliberately absent: the forbidden-token, quota-limit and funding
-* checks all need the *delta* an operation applies, and `OperationState` reports
-* only the state after it. Weighing them against absolutes would refuse a
-* forbidden token the account merely holds, or a quota the operation never
-* touched. The engine performed all three during the walk, so a simulation that
-* came back `ok` has already passed them.
-*/
-function checkSimulation(input, options = {}) {
-	const { sdk, state } = input;
-	const suite = sdk.marketRegister.findCreditManager(state.creditManager);
-	return marketIssues(suite) || checkDebtInBand({
-		debt: state.totalDebt.value,
-		minDebt: suite.creditFacade.minDebt,
-		maxDebt: suite.creditFacade.maxDebt,
-		underlying: toToken(sdk, suite.market.pool.underlying),
-		allowZero: true
-	}) || quotaCountIssue(suite, state) || collateralIssue(state, options);
-}
-//#endregion
-export { checkSimulation };

package/dist/esm/preview/validate/index.js

@@ -1,3 +0,0 @@
-import { checkOperation, collateralIssue, marketIssues, quotaCountIssue } from "./checkOperation.js";
-import { checkSimulation } from "./checkSimulation.js";
-export { checkOperation, checkSimulation, collateralIssue, marketIssues, quotaCountIssue };

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

@@ -1,108 +0,0 @@
-//#region src/sdk/prepare/errors.ts
-/**
-* One sentence per refusal, naming what was ruled out rather than restating the
-* numbers the error already carries.
-*
-* English and loggable, not a string to put on a screen: a form renders the
-* code and the amounts in its own words, see {@link IGearboxError.message}.
-**/
-const MESSAGES = {
-	debtOutOfRange: "The debt this request implies is outside the market's band.",
-	leverageOutOfRange: "The leverage asked for cannot be expressed as a plan.",
-	insufficientSourceBalance: "Neither the account nor the wallet holds enough to fund this request.",
-	unsupportedCollateralToken: "This flow does not accept that token.",
-	unsupportedTokenPair: "No route exists between these two tokens.",
-	noDelayedRoute: "This request cannot be served as a delayed redemption.",
-	multipleDelayedWithdrawals: "The source asset has several redemption venues and none was named.",
-	withdrawalInProgress: "A redemption of this asset is already in flight on the account.",
-	noRecordedIntent: "The claim names no operation to resume.",
-	marketPaused: "The market is paused.",
-	marketExpired: "The market is past its expiration date.",
-	insufficientPoolLiquidity: "The pool cannot lend what this plan draws.",
-	quotaLimitReached: "The market takes no more quota for a token this plan holds.",
-	forbiddenToken: "This plan would increase the balance of a forbidden token.",
-	insufficientCollateral: "The account would end this transaction under-collateralised.",
-	poolSunset: "The pool is winding down and takes no more deposits.",
-	quotaCountExceeded: "The account would hold more quoted tokens than the facade enables at once.",
-	malformedTransaction: "The transaction could not be replayed."
-};
-/**
-* The engine's refusal, as the error the namespace answers with.
-*
-* One place does the lifting, so the two shapes cannot drift: `reason` becomes
-* `code`, the detail is spread onto the error, and the sentence comes from
-* {@link MESSAGES}. A malformed transaction is spelled out rather than spread,
-* because its detail names a `code` and a `message` of its own and they are not
-* the envelope's.
-*
-* Generic over the issue it is handed, so a call site that already knows the
-* reason gets that reason's error back rather than a union to narrow again.
-**/
-function toRefusalError(issue) {
-	if (issue.reason === "malformedTransaction") return {
-		code: "malformedTransaction",
-		message: MESSAGES.malformedTransaction,
-		previewCode: issue.detail.code,
-		detail: issue.detail.message
-	};
-	return {
-		code: issue.reason,
-		message: MESSAGES[issue.reason],
-		...issue.detail
-	};
-}
-/**
-* {@inheritDoc NoStrategyTargetCollateralError}
-**/
-function noStrategyTargetCollateral(creditManager) {
-	return {
-		code: "noStrategyTargetCollateral",
-		message: `Credit manager ${creditManager} has no strategy target collateral, and none was named.`,
-		creditManager
-	};
-}
-/**
-* {@inheritDoc CreditAccountNotEmptyError}
-**/
-function creditAccountNotEmpty(creditAccount) {
-	return {
-		code: "creditAccountNotEmpty",
-		message: `Credit account ${creditAccount} carries debt or quotas.`,
-		creditAccount
-	};
-}
-/**
-* {@inheritDoc CreditAccountNotFoundError}
-**/
-function creditAccountNotFound(creditAccount) {
-	return {
-		code: "creditAccountNotFound",
-		message: `Credit account not found: ${creditAccount}.`,
-		creditAccount
-	};
-}
-/**
-* {@inheritDoc EmptyOpenTakesNothingError}
-**/
-function emptyOpenTakesNothing() {
-	return {
-		code: "emptyOpenTakesNothing",
-		message: "An empty opening takes no collateral, no account to reuse and no leverage."
-	};
-}
-/**
-* {@inheritDoc UnexpectedFailureError}
-*
-* Takes what was thrown, whatever that is: a `throw` is not obliged to raise an
-* `Error`, and `cause` promises one.
-**/
-function unexpectedFailure(thrown) {
-	const cause = thrown instanceof Error ? thrown : new Error(String(thrown));
-	return {
-		code: "unexpectedFailure",
-		message: `The SDK could not prepare this operation: ${cause.message}`,
-		cause
-	};
-}
-//#endregion
-export { creditAccountNotEmpty, creditAccountNotFound, emptyOpenTakesNothing, noStrategyTargetCollateral, toRefusalError, unexpectedFailure };

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

@@ -1,46 +0,0 @@
-//#region src/model/errors.d.ts
-/**
- * The failure vocabulary the SDK answers in.
- *
- * A request that the protocol, the market or the request's own numbers rule out
- * is not an exception: it is an answer, and a screen shows it the way it shows
- * any other. So a method that can be refused returns an {@link SDKReturn}
- * envelope rather than throwing, and what it puts in the failure half is one of
- * these — never a bare string, never a boolean the caller has to interpret.
- *
- * A thrown exception still means what it always did: the SDK could not do its
- * job (a read failed, a contract reverted unexpectedly, an argument is wrong).
- * Those are bugs and outages, not refusals of the request.
- **/
-/**
- * What every error the SDK reports has.
- *
- * `code` is the discriminant: switch on it and the error narrows to the shape
- * carrying that failure's own numbers, so a caller reads `available` and
- * `required` off the error rather than re-deriving them from the request.
- *
- * The codes themselves are per namespace — there is no SDK-wide enumeration of
- * them, because the set a method can answer with is part of that method's
- * contract, see the `E` of {@link SDKReturn}.
- **/
-interface IGearboxError {
-  /**
-   * Machine-readable identity of the failure, and the discriminant of the
-   * union a method returns.
-   **/
-  code: string;
-  /**
-   * One sentence naming what was refused, in English, safe to log. Not a
-   * message to show a user as-is: a screen renders the code and the numbers
-   * beside it in its own words and its own language.
-   **/
-  message: string;
-  /**
-   * The failure this one was raised for, where one error stands in front of
-   * another. Absent for a refusal that is its own reason, which is most of
-   * them.
-   **/
-  cause?: IGearboxError | Error;
-}
-//#endregion
-export { IGearboxError };

package/dist/types/onchain/accounts/withdrawal-compressor/errors.d.ts

@@ -1,20 +0,0 @@
-import { IGearboxError } from "../../../model/errors.js";
-import "../../../model/index.js";
-import { Hex } from "viem";
-//#region src/onchain/accounts/withdrawal-compressor/errors.d.ts
-/**
- * Refusal answered when a delayed-withdrawal request or redemption log carries
- * non-empty `extraData` that cannot be decoded as a `DelayedIntent`.
- * Requests produced by our stack always encode a valid intent, so garbage
- * here means a malformed/foreign transaction that must not be previewed as
- * if it were fine. A plain returned object — not a thrown `Error`.
- */
-interface InvalidDelayedIntentError extends IGearboxError {
-  code: "invalidDelayedIntent";
-  /** Raw `extraData` that failed to decode. */
-  extraData: Hex;
-  /** The decoding failure this refusal stands in front of. */
-  cause?: Error;
-}
-//#endregion
-export { InvalidDelayedIntentError };

package/dist/types/onchain/market/zapper/errors.d.ts

@@ -1,18 +0,0 @@
-import { IGearboxError } from "../../../model/errors.js";
-import "../../../model/index.js";
-import { Address } from "viem";
-//#region src/onchain/market/zapper/errors.d.ts
-/**
- * Refusal answered when a zapper call uses a function other than a known
- * `deposit`/`redeem` variant. A plain returned object per the SDK's refusal
- * vocabulary — not a thrown `Error`.
- */
-interface UnsupportedZapperFunctionError extends IGearboxError {
-  code: "unsupportedZapperFunction";
-  /** Zapper contract the call targets. */
-  zapper: Address;
-  /** Decoded function name the SDK cannot preview. */
-  functionName: string;
-}
-//#endregion
-export { UnsupportedZapperFunctionError };

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

@@ -1,164 +0,0 @@
-import { Bps, Token, TokenAmount } from "../../model/primitives.js";
-import { IGearboxError } from "../../model/errors.js";
-import { MalformedPreviewError } from "../../model/previews.js";
-import "../../model/index.js";
-import { BorrowLimitBinding, PreviewIssue } from "./refusal.js";
-import { Address } from "viem";
-//#region src/onchain/validation/checks.d.ts
-/**
- * Every refusal the protocol can pass on an operation, as values.
- *
- * Each check is handed the numbers it compares — never a suite, a market or an
- * SDK — so the engine, `checkOperation` and the strategy lists share one
- * implementation.
- *
- * Ladders stay with the caller because they differ deliberately: the engine
- * reports the tightest ceiling it found, the account-opening path the first one
- * exceeded in its own order.
- */
-/** A factor at or below this is refused; kept for the callers that size on it. */
-declare const MIN_HF_LIMITED = 10100n;
-/** The same bar as a `required` argument — the lowest factor that passes. */
-declare const MIN_HEALTH_FACTOR_FORM = 10101;
-/** The bar the facade itself enforces: an account may end exactly at 1.0. */
-declare const MIN_HEALTH_FACTOR_FACADE = 10000;
-/**
- * The safe-price bar a form holds an account to. A step above the facade's,
- * because a factor of exactly 1.0 at safe prices is already a refusal.
- */
-declare const MIN_SAFE_HEALTH_FACTOR_FORM = 10001;
-/** A refusal names what a limit was measured in, never what it is worth. */
-declare function amountOf(token: Token, value: bigint): TokenAmount;
-/** The credit manager takes no multicall while it is paused. */
-declare function checkCreditManagerPaused(args: {
-  isPaused: boolean;
-  creditManager: Address;
-}): PreviewIssue | null;
-/** Past its expiration date the facade takes no more multicalls. */
-declare function checkMarketExpired(args: {
-  isExpired: boolean;
-  creditManager: Address;
-  /** Unix seconds, as the facade reports it. */
-  expirationDate: number;
-}): PreviewIssue | null;
-/** A paused pool neither takes deposits nor pays out. */
-declare function checkPoolPaused(args: {
-  isPaused: boolean;
-  pool: Address;
-}): PreviewIssue | null;
-/**
- * A pool winding down still pays out, so only what puts money in is refused.
- */
-declare function checkPoolSunset(args: {
-  isSunset: boolean;
-  isDeposit: boolean;
-  pool: Address;
-}): PreviewIssue | null;
-/**
- * What the pool will hand over, against what is asked for.
- *
- * `binding` and `available` are the caller's answer to "which ceiling stands in
- * the way", not this check's: see the ladder note above. `solutionAmount` is
- * the largest position still openable, left out when none is.
- */
-declare function checkBorrowLimit(args: {
-  requested: bigint;
-  available: bigint;
-  binding: BorrowLimitBinding;
-  underlying: Token;
-  solutionAmount?: bigint;
-}): PreviewIssue | null;
-/**
- * What the pool can pay out, against what is being taken out.
- *
- * The operator is not `checkBorrowLimit`'s: a pool holding exactly the amount
- * asked for still cannot serve it, so equality is already a refusal. That is
- * the rule the legacy withdrawal validator enforced and it is preserved to the
- * unit.
- */
-declare function checkPoolPayout(args: {
-  requested: bigint;
-  available: bigint;
-  underlying: Token;
-}): PreviewIssue | null;
-/**
- * A debt the facade would revert on.
- *
- * `allowZero` is the one place the two callers genuinely disagree: an account
- * being adjusted may end owing nothing, while one being opened may not — so the
- * exemption is stated rather than assumed.
- */
-declare function checkDebtInBand(args: {
-  debt: bigint;
-  minDebt: bigint;
-  maxDebt: bigint;
-  underlying: Token;
-  allowZero: boolean;
-}): PreviewIssue | null;
-/** Leverage below 1x is not a position, it is a withdrawal. */
-declare function checkLeverageAtLeastOne(args: {
-  leverage: bigint;
-  min: bigint;
-}): PreviewIssue | null;
-/**
- * The account against its debt, at whichever bar the caller holds it to.
- *
- * An unread factor counts as failing: a check that cannot see the number is not
- * evidence that the number is fine.
- */
-declare function checkCollateralised(args: {
-  healthFactor: Bps | undefined;
-  /** The lowest acceptable factor — a factor equal to it passes. */
-  required: Bps;
-  safePrices: boolean;
-  /**
-   * The factor the account stands at now. Given, an operation that raises it
-   * passes even from under the bar: an account already below is rescued by
-   * exactly the top-ups a flat bar would refuse.
-   */
-  improvesFrom?: Bps;
-}): PreviewIssue | null;
-/** A token the market will not let the account hold. */
-declare function checkForbiddenToken(args: {
-  token: Token;
-  isForbidden: boolean;
-}): PreviewIssue | null;
-/**
- * The room the keeper still has for a token's quota, in the underlying.
- *
- * `requested` is absent for a token the market opened no quota for at all —
- * nothing was weighed against a limit, the token simply counts as no collateral.
- */
-declare function checkQuotaLimit(args: {
-  token: Token;
-  requested: bigint | undefined;
-  available: bigint;
-  underlying: Token;
-}): PreviewIssue | null;
-/** How many quoted tokens the facade enables at once. */
-declare function checkQuotaCount(args: {
-  count: number;
-  max: number;
-}): PreviewIssue | null;
-/** What the operation is funded from, against what is there. */
-declare function checkFunding(args: {
-  token: Token;
-  required: bigint;
-  held: bigint;
-}): PreviewIssue | null;
-/**
- * The SDK could not replay the transaction.
- *
- * Only a {@link MalformedPreviewError} lands here. An `unpriceableToken`
- * warning says the transaction is fine and the SDK could not fully evaluate
- * it, which is a caveat on the numbers rather than a reason to refuse — it
- * stays on the preview for the caller to surface.
- */
-declare function checkPreviewError(warning: IGearboxError | undefined): PreviewIssue | null;
-/**
- * Whether the preview warning means the transaction itself is malformed,
- * rather than that only the evaluation was incomplete.
- */
-declare function isMalformedPreviewError(warning: IGearboxError): warning is MalformedPreviewError;
-//#endregion
-export { MIN_HEALTH_FACTOR_FACADE, MIN_HEALTH_FACTOR_FORM, MIN_HF_LIMITED, MIN_SAFE_HEALTH_FACTOR_FORM, amountOf, checkBorrowLimit, checkCollateralised, checkCreditManagerPaused, checkDebtInBand, checkForbiddenToken, checkFunding, checkLeverageAtLeastOne, checkMarketExpired, checkPoolPaused, checkPoolPayout, checkPoolSunset, checkPreviewError, checkQuotaCount, checkQuotaLimit, isMalformedPreviewError };