@morpho-org/consumer-sdk 0.4.0 → 0.5.0

package/lib/helpers/constant.js

@@ -1,5 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_SLIPPAGE_TOLERANCE = void 0;
+exports.MAX_ABSOLUTE_SHARE_PRICE = exports.DEFAULT_LLTV_BUFFER = exports.MAX_SLIPPAGE_TOLERANCE = void 0;
 const blue_sdk_1 = require("@morpho-org/blue-sdk");
+/** Maximum slippage tolerance: 10% */
 exports.MAX_SLIPPAGE_TOLERANCE = blue_sdk_1.MathLib.WAD / 10n;
+/** Default LLTV buffer: 0.5% below LLTV. Prevents instant liquidation on new positions. */
+exports.DEFAULT_LLTV_BUFFER = blue_sdk_1.MathLib.WAD / 200n;
+/** Maximum absolute share price cap (100 RAY). Prevents absurd maxSharePrice values in repay. */
+exports.MAX_ABSOLUTE_SHARE_PRICE = 100n * blue_sdk_1.MathLib.RAY;

package/lib/helpers/index.d.ts

@@ -1 +1,4 @@
+export { computeReallocations } from "./computeReallocations";
 export { addTransactionMetadata } from "./metadata";
+export { computeMaxRepaySharePrice, computeMinBorrowSharePrice, } from "./slippage";
+export { validateAccrualPosition, validateChainId, validateNativeCollateral, validatePositionHealth, validatePositionHealthAfterWithdraw, validateReallocations, validateRepayAmount, validateRepayParams, validateRepayShares, validateSlippageTolerance, validateUserAddress, } from "./validate";

package/lib/helpers/index.js

@@ -1,5 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addTransactionMetadata = void 0;
+exports.validateUserAddress = exports.validateSlippageTolerance = exports.validateRepayShares = exports.validateRepayParams = exports.validateRepayAmount = exports.validateReallocations = exports.validatePositionHealthAfterWithdraw = exports.validatePositionHealth = exports.validateNativeCollateral = exports.validateChainId = exports.validateAccrualPosition = exports.computeMinBorrowSharePrice = exports.computeMaxRepaySharePrice = exports.addTransactionMetadata = exports.computeReallocations = void 0;
+var computeReallocations_1 = require("./computeReallocations");
+Object.defineProperty(exports, "computeReallocations", { enumerable: true, get: function () { return computeReallocations_1.computeReallocations; } });
 var metadata_1 = require("./metadata");
 Object.defineProperty(exports, "addTransactionMetadata", { enumerable: true, get: function () { return metadata_1.addTransactionMetadata; } });
+var slippage_1 = require("./slippage");
+Object.defineProperty(exports, "computeMaxRepaySharePrice", { enumerable: true, get: function () { return slippage_1.computeMaxRepaySharePrice; } });
+Object.defineProperty(exports, "computeMinBorrowSharePrice", { enumerable: true, get: function () { return slippage_1.computeMinBorrowSharePrice; } });
+var validate_1 = require("./validate");
+Object.defineProperty(exports, "validateAccrualPosition", { enumerable: true, get: function () { return validate_1.validateAccrualPosition; } });
+Object.defineProperty(exports, "validateChainId", { enumerable: true, get: function () { return validate_1.validateChainId; } });
+Object.defineProperty(exports, "validateNativeCollateral", { enumerable: true, get: function () { return validate_1.validateNativeCollateral; } });
+Object.defineProperty(exports, "validatePositionHealth", { enumerable: true, get: function () { return validate_1.validatePositionHealth; } });
+Object.defineProperty(exports, "validatePositionHealthAfterWithdraw", { enumerable: true, get: function () { return validate_1.validatePositionHealthAfterWithdraw; } });
+Object.defineProperty(exports, "validateReallocations", { enumerable: true, get: function () { return validate_1.validateReallocations; } });
+Object.defineProperty(exports, "validateRepayAmount", { enumerable: true, get: function () { return validate_1.validateRepayAmount; } });
+Object.defineProperty(exports, "validateRepayParams", { enumerable: true, get: function () { return validate_1.validateRepayParams; } });
+Object.defineProperty(exports, "validateRepayShares", { enumerable: true, get: function () { return validate_1.validateRepayShares; } });
+Object.defineProperty(exports, "validateSlippageTolerance", { enumerable: true, get: function () { return validate_1.validateSlippageTolerance; } });
+Object.defineProperty(exports, "validateUserAddress", { enumerable: true, get: function () { return validate_1.validateUserAddress; } });

package/lib/helpers/slippage.d.ts

@@ -0,0 +1,46 @@
+import { type Market } from "@morpho-org/blue-sdk";
+/**
+ * Computes the minimum borrow share price (in RAY, 1e27) for slippage protection.
+ *
+ * Mirrors the on-chain check in GeneralAdapter1's `morphoBorrow`:
+ * ```solidity
+ * require(borrowedAssets.rDivDown(borrowedShares) >= minSharePriceE27)
+ * ```
+ *
+ * @param params - Computation parameters.
+ * @param params.borrowAmount - The amount of assets to borrow.
+ * @param params.market - The market to compute the minimum borrow share price for.
+ * @param params.slippageTolerance - Slippage tolerance in WAD (e.g. 0.003e18 = 0.3%).
+ * @returns minSharePriceE27 in RAY scale (1e27).
+ */
+export declare function computeMinBorrowSharePrice(params: {
+    borrowAmount: bigint;
+    market: Market;
+    slippageTolerance: bigint;
+}): bigint;
+/**
+ * Computes the maximum repay share price (in RAY, 1e27) for slippage protection.
+ *
+ * Supports both repay-by-assets and repay-by-shares paths:
+ * - By assets: derives expected shares from the repay amount via `toBorrowShares("Down")`.
+ * - By shares: derives expected assets from the shares via `toBorrowAssets("Up")`.
+ *
+ * Direction is opposite of borrow's `minSharePrice`:
+ * - Borrow uses `(WAD - slippage)` → lower bound (protects borrower from getting fewer assets per share).
+ * - Repay uses `(WAD + slippage)` → upper bound (protects repayer from paying too many assets per share).
+ *
+ * Capped at {@link MAX_ABSOLUTE_SHARE_PRICE} to prevent absurd values.
+ *
+ * @param params - Computation parameters.
+ * @param params.repayAssets - The amount of assets to repay (0n when repaying by shares).
+ * @param params.repayShares - The amount of shares to repay (0n when repaying by assets).
+ * @param params.market - The market to compute the maximum repay share price for.
+ * @param params.slippageTolerance - Slippage tolerance in WAD (e.g. 0.003e18 = 0.3%).
+ * @returns maxSharePriceE27 in RAY scale (1e27).
+ */
+export declare function computeMaxRepaySharePrice(params: {
+    repayAssets: bigint;
+    repayShares: bigint;
+    market: Market;
+    slippageTolerance: bigint;
+}): bigint;

package/lib/helpers/slippage.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeMinBorrowSharePrice = computeMinBorrowSharePrice;
+exports.computeMaxRepaySharePrice = computeMaxRepaySharePrice;
+const blue_sdk_1 = require("@morpho-org/blue-sdk");
+const types_1 = require("../types");
+const constant_1 = require("./constant");
+/**
+ * Computes the minimum borrow share price (in RAY, 1e27) for slippage protection.
+ *
+ * Mirrors the on-chain check in GeneralAdapter1's `morphoBorrow`:
+ * ```solidity
+ * require(borrowedAssets.rDivDown(borrowedShares) >= minSharePriceE27)
+ * ```
+ *
+ * @param params - Computation parameters.
+ * @param params.borrowAmount - The amount of assets to borrow.
+ * @param params.market - The market to compute the minimum borrow share price for.
+ * @param params.slippageTolerance - Slippage tolerance in WAD (e.g. 0.003e18 = 0.3%).
+ * @returns minSharePriceE27 in RAY scale (1e27).
+ */
+function computeMinBorrowSharePrice(params) {
+    const { borrowAmount, market, slippageTolerance } = params;
+    if (slippageTolerance >= blue_sdk_1.MathLib.WAD) {
+        throw new types_1.ExcessiveSlippageToleranceError(slippageTolerance);
+    }
+    const expectedShares = market.toBorrowShares(borrowAmount, "Up");
+    if (expectedShares === 0n) {
+        throw new types_1.ShareDivideByZeroError(market.params.id);
+    }
+    return blue_sdk_1.MathLib.mulDivDown(borrowAmount, blue_sdk_1.MathLib.wToRay(blue_sdk_1.MathLib.WAD - slippageTolerance), expectedShares);
+}
+/**
+ * Computes the maximum repay share price (in RAY, 1e27) for slippage protection.
+ *
+ * Supports both repay-by-assets and repay-by-shares paths:
+ * - By assets: derives expected shares from the repay amount via `toBorrowShares("Down")`.
+ * - By shares: derives expected assets from the shares via `toBorrowAssets("Up")`.
+ *
+ * Direction is opposite of borrow's `minSharePrice`:
+ * - Borrow uses `(WAD - slippage)` → lower bound (protects borrower from getting fewer assets per share).
+ * - Repay uses `(WAD + slippage)` → upper bound (protects repayer from paying too many assets per share).
+ *
+ * Capped at {@link MAX_ABSOLUTE_SHARE_PRICE} to prevent absurd values.
+ *
+ * @param params - Computation parameters.
+ * @param params.repayAssets - The amount of assets to repay (0n when repaying by shares).
+ * @param params.repayShares - The amount of shares to repay (0n when repaying by assets).
+ * @param params.market - The market to compute the maximum repay share price for.
+ * @param params.slippageTolerance - Slippage tolerance in WAD (e.g. 0.003e18 = 0.3%).
+ * @returns maxSharePriceE27 in RAY scale (1e27).
+ */
+function computeMaxRepaySharePrice(params) {
+    const { repayAssets, repayShares, market, slippageTolerance } = params;
+    if (slippageTolerance >= blue_sdk_1.MathLib.WAD) {
+        throw new types_1.ExcessiveSlippageToleranceError(slippageTolerance);
+    }
+    let assets;
+    let shares;
+    if (repayShares > 0n) {
+        assets = market.toBorrowAssets(repayShares, "Up");
+        shares = repayShares;
+    }
+    else {
+        assets = repayAssets;
+        shares = market.toBorrowShares(repayAssets, "Down");
+    }
+    if (shares === 0n) {
+        throw new types_1.ShareDivideByZeroError(market.params.id);
+    }
+    const maxSharePrice = blue_sdk_1.MathLib.mulDivUp(assets, blue_sdk_1.MathLib.wToRay(blue_sdk_1.MathLib.WAD + slippageTolerance), shares);
+    return blue_sdk_1.MathLib.min(maxSharePrice, constant_1.MAX_ABSOLUTE_SHARE_PRICE);
+}

package/lib/helpers/validate.d.ts

@@ -0,0 +1,150 @@
+import { type AccrualPosition, type MarketId } from "@morpho-org/blue-sdk";
+import { type Address } from "viem";
+import { type VaultReallocation } from "../types";
+/**
+ * Validates that the provided user address matches the client's connected account.
+ * Only enforced when the client has an account — skips validation for public clients
+ * (e.g., when building transactions to be signed externally).
+ *
+ * Throws {@link AddressMismatchError} if the client account is present
+ * and does not match `userAddress`.
+ *
+ * @param clientAccountAddress - The client's account address (may be undefined).
+ * @param userAddress - The user address provided by the caller.
+ */
+export declare const validateUserAddress: (clientAccountAddress: Address | undefined, userAddress: Address) => void;
+/**
+ * Validates that the accrual position belongs to the expected market and user.
+ * Throws {@link MarketIdMismatchError} if the position's market ID
+ * does not match the expected market.
+ * Throws {@link AccrualPositionUserMismatchError} if the position's user
+ * does not match the expected user.
+ *
+ * @param params - Validation parameters.
+ * @param params.positionData - The accrual position to validate.
+ * @param params.expectedMarketId - The market ID the position must belong to.
+ * @param params.expectedUser - The user address the position must belong to.
+ */
+export declare const validateAccrualPosition: (params: {
+    positionData: AccrualPosition;
+    expectedMarketId: MarketId;
+    expectedUser: Address;
+}) => void;
+/**
+ * Validates that the resulting position stays within the safe LTV threshold
+ * (LLTV minus buffer) after supplying additional collateral and borrowing.
+ *
+ * @param params - Validation parameters.
+ * @param params.positionData - The current accrual position with market data.
+ * @param params.additionalCollateral - Amount of collateral being added.
+ * @param params.borrowAmount - Amount being borrowed.
+ * @param params.marketId - The market identifier (for error messages).
+ * @param params.lltv - The market's liquidation LTV.
+ */
+export declare const validatePositionHealth: (params: {
+    positionData: AccrualPosition;
+    additionalCollateral: bigint;
+    borrowAmount: bigint;
+    marketId: MarketId;
+    lltv: bigint;
+}) => void;
+/**
+ * Validates that the viem client chain ID matches the expected chain ID.
+ * Throws {@link ChainIdMismatchError} if they differ.
+ *
+ * @param clientChainId - Chain ID reported by the viem client (may be undefined).
+ * @param expectedChainId - Chain ID expected by the entity or action.
+ */
+export declare const validateChainId: (clientChainId: number | undefined, expectedChainId: number) => void;
+/**
+ * Validates that the given collateral token is the chain's wrapped native token.
+ * Throws {@link ChainWNativeMissingError} if wNative is not configured for the chain.
+ * Throws {@link NativeAmountOnNonWNativeCollateralError} if collateral is not wNative.
+ *
+ * @param chainId - The chain to look up wNative on.
+ * @param collateralToken - The market's collateral token address.
+ */
+export declare const validateNativeCollateral: (chainId: number, collateralToken: Address) => void;
+/**
+ * Validates that the resulting position stays within the safe LTV threshold
+ * (LLTV minus buffer) after withdrawing collateral.
+ *
+ * @param params - Validation parameters.
+ * @param params.positionData - The current accrual position with market data.
+ * @param params.withdrawAmount - Amount of collateral being withdrawn.
+ * @param params.lltv - The market's liquidation LTV.
+ * @param params.marketId - The market identifier (for error messages).
+ */
+export declare const validatePositionHealthAfterWithdraw: (params: {
+    positionData: AccrualPosition;
+    withdrawAmount: bigint;
+    lltv: bigint;
+    marketId: MarketId;
+}) => void;
+/**
+ * Validates that the repay amount assets does not exceed the outstanding debt.
+ *
+ * @param params - Validation parameters.
+ * @param params.positionData - The current accrual position.
+ * @param params.repayAssets - The amount of assets to repay.
+ * @param params.marketId - The market identifier (for error messages).
+ */
+export declare const validateRepayAmount: (params: {
+    positionData: AccrualPosition;
+    repayAssets: bigint;
+    marketId: MarketId;
+}) => void;
+/**
+ * Validates that the repay shares do not exceed the outstanding borrow shares.
+ *
+ * @param params - Validation parameters.
+ * @param params.positionData - The current accrual position.
+ * @param params.repayShares - The amount of shares to repay.
+ * @param params.marketId - The market identifier (for error messages).
+ */
+export declare const validateRepayShares: (params: {
+    positionData: AccrualPosition;
+    repayShares: bigint;
+    marketId: MarketId;
+}) => void;
+/**
+ * Validates the common repay input parameters shared by `marketV1Repay`
+ * and `marketV1RepayWithdrawCollateral`.
+ *
+ * @param params - Validation parameters.
+ * @param params.assets - Repay assets amount (0n when repaying by shares).
+ * @param params.shares - Repay shares amount (0n when repaying by assets).
+ * @param params.transferAmount - ERC20 amount to transfer to GeneralAdapter1.
+ * @param params.maxSharePrice - Maximum repay share price (in ray). Must be positive.
+ * @param params.marketId - The market identifier (for error messages).
+ */
+export declare const validateRepayParams: (params: {
+    assets: bigint;
+    shares: bigint;
+    transferAmount: bigint;
+    maxSharePrice: bigint;
+    marketId: MarketId;
+}) => void;
+/**
+ * Validates that vault reallocations are well-formed.
+ *
+ * Enforces the following invariants for each {@link VaultReallocation}:
+ * - `fee` must be non-negative.
+ * - `withdrawals` must be non-empty.
+ * - Every withdrawal `amount` must be strictly positive.
+ * - No withdrawal may target `targetMarketId` (the borrow market).
+ * - Withdrawal market IDs must be strictly ascending (required by `PublicAllocator.reallocateTo`).
+ *
+ * @param reallocations - The reallocations to validate.
+ * @param targetMarketId - The ID of the market being borrowed from. No withdrawal may reference this market.
+ */
+export declare const validateReallocations: (reallocations: readonly VaultReallocation[], targetMarketId: MarketId) => void;
+/**
+ * Validates that a slippage tolerance is within an acceptable range.
+ *
+ * Throws {@link NegativeSlippageToleranceError} if negative.
+ * Throws {@link ExcessiveSlippageToleranceError} if greater than {@link MAX_SLIPPAGE_TOLERANCE}.
+ *
+ * @param slippageTolerance - The slippage tolerance in WAD.
+ */
+export declare const validateSlippageTolerance: (slippageTolerance: bigint) => void;

package/lib/helpers/validate.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSlippageTolerance = exports.validateReallocations = exports.validateRepayParams = exports.validateRepayShares = exports.validateRepayAmount = exports.validatePositionHealthAfterWithdraw = exports.validateNativeCollateral = exports.validateChainId = exports.validatePositionHealth = exports.validateAccrualPosition = exports.validateUserAddress = void 0;
+const blue_sdk_1 = require("@morpho-org/blue-sdk");
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+const viem_1 = require("viem");
+const types_1 = require("../types");
+const constant_1 = require("./constant");
+/**
+ * Validates that the provided user address matches the client's connected account.
+ * Only enforced when the client has an account — skips validation for public clients
+ * (e.g., when building transactions to be signed externally).
+ *
+ * Throws {@link AddressMismatchError} if the client account is present
+ * and does not match `userAddress`.
+ *
+ * @param clientAccountAddress - The client's account address (may be undefined).
+ * @param userAddress - The user address provided by the caller.
+ */
+const validateUserAddress = (clientAccountAddress, userAddress) => {
+    if (clientAccountAddress !== undefined &&
+        !(0, viem_1.isAddressEqual)(clientAccountAddress, userAddress)) {
+        throw new types_1.AddressMismatchError(clientAccountAddress, userAddress);
+    }
+};
+exports.validateUserAddress = validateUserAddress;
+/**
+ * Validates that the accrual position belongs to the expected market and user.
+ * Throws {@link MarketIdMismatchError} if the position's market ID
+ * does not match the expected market.
+ * Throws {@link AccrualPositionUserMismatchError} if the position's user
+ * does not match the expected user.
+ *
+ * @param params - Validation parameters.
+ * @param params.positionData - The accrual position to validate.
+ * @param params.expectedMarketId - The market ID the position must belong to.
+ * @param params.expectedUser - The user address the position must belong to.
+ */
+const validateAccrualPosition = (params) => {
+    const { positionData, expectedMarketId, expectedUser } = params;
+    if (positionData.marketId !== expectedMarketId) {
+        throw new types_1.MarketIdMismatchError(positionData.marketId, expectedMarketId);
+    }
+    if (!(0, viem_1.isAddressEqual)(positionData.user, expectedUser)) {
+        throw new types_1.AccrualPositionUserMismatchError(positionData.user, expectedUser);
+    }
+};
+exports.validateAccrualPosition = validateAccrualPosition;
+/**
+ * Validates that the resulting position stays within the safe LTV threshold
+ * (LLTV minus buffer) after supplying additional collateral and borrowing.
+ *
+ * @param params - Validation parameters.
+ * @param params.positionData - The current accrual position with market data.
+ * @param params.additionalCollateral - Amount of collateral being added.
+ * @param params.borrowAmount - Amount being borrowed.
+ * @param params.marketId - The market identifier (for error messages).
+ * @param params.lltv - The market's liquidation LTV.
+ */
+const validatePositionHealth = (params) => {
+    const { positionData, additionalCollateral, borrowAmount, marketId, lltv } = params;
+    const { price } = positionData.market;
+    if (!price) {
+        throw new types_1.MissingMarketPriceError(marketId);
+    }
+    const totalCollateralAfter = positionData.collateral + additionalCollateral;
+    const collateralValueAfter = blue_sdk_1.MathLib.mulDivDown(totalCollateralAfter, price, blue_sdk_1.ORACLE_PRICE_SCALE);
+    const effectiveLltv = lltv > constant_1.DEFAULT_LLTV_BUFFER ? lltv - constant_1.DEFAULT_LLTV_BUFFER : 0n;
+    const maxSafeBorrowAfter = blue_sdk_1.MathLib.wMulDown(collateralValueAfter, effectiveLltv);
+    const totalBorrowAfter = positionData.borrowAssets + borrowAmount + 1n; // +1 to account for share-to-asset rounding (happens when the borrow amount doesn't divide evenly into shares)
+    if (totalBorrowAfter > maxSafeBorrowAfter) {
+        const maxSafeAdditionalBorrow = blue_sdk_1.MathLib.zeroFloorSub(maxSafeBorrowAfter, positionData.borrowAssets);
+        throw new types_1.BorrowExceedsSafeLtvError(borrowAmount, maxSafeAdditionalBorrow);
+    }
+};
+exports.validatePositionHealth = validatePositionHealth;
+/**
+ * Validates that the viem client chain ID matches the expected chain ID.
+ * Throws {@link ChainIdMismatchError} if they differ.
+ *
+ * @param clientChainId - Chain ID reported by the viem client (may be undefined).
+ * @param expectedChainId - Chain ID expected by the entity or action.
+ */
+const validateChainId = (clientChainId, expectedChainId) => {
+    if (clientChainId !== expectedChainId) {
+        throw new types_1.ChainIdMismatchError(clientChainId, expectedChainId);
+    }
+};
+exports.validateChainId = validateChainId;
+/**
+ * Validates that the given collateral token is the chain's wrapped native token.
+ * Throws {@link ChainWNativeMissingError} if wNative is not configured for the chain.
+ * Throws {@link NativeAmountOnNonWNativeCollateralError} if collateral is not wNative.
+ *
+ * @param chainId - The chain to look up wNative on.
+ * @param collateralToken - The market's collateral token address.
+ */
+const validateNativeCollateral = (chainId, collateralToken) => {
+    const { wNative } = (0, blue_sdk_1.getChainAddresses)(chainId);
+    if (!(0, morpho_ts_1.isDefined)(wNative)) {
+        throw new types_1.ChainWNativeMissingError(chainId);
+    }
+    if (!(0, viem_1.isAddressEqual)(collateralToken, wNative)) {
+        throw new types_1.NativeAmountOnNonWNativeCollateralError(collateralToken, wNative);
+    }
+};
+exports.validateNativeCollateral = validateNativeCollateral;
+/**
+ * Validates that the resulting position stays within the safe LTV threshold
+ * (LLTV minus buffer) after withdrawing collateral.
+ *
+ * @param params - Validation parameters.
+ * @param params.positionData - The current accrual position with market data.
+ * @param params.withdrawAmount - Amount of collateral being withdrawn.
+ * @param params.lltv - The market's liquidation LTV.
+ * @param params.marketId - The market identifier (for error messages).
+ */
+const validatePositionHealthAfterWithdraw = (params) => {
+    const { positionData, withdrawAmount, lltv, marketId } = params;
+    if (positionData.marketId !== marketId) {
+        throw new types_1.MarketIdMismatchError(positionData.marketId, marketId);
+    }
+    if (withdrawAmount > positionData.collateral) {
+        throw new types_1.WithdrawExceedsCollateralError({
+            withdrawAmount,
+            available: positionData.collateral,
+            market: marketId,
+        });
+    }
+    // No debt means position is always healthy — oracle price not needed.
+    if (positionData.borrowAssets === 0n) {
+        return;
+    }
+    const { price } = positionData.market;
+    if (!price) {
+        throw new types_1.MissingMarketPriceError(positionData.marketId);
+    }
+    const collateralAfter = positionData.collateral - withdrawAmount;
+    const collateralValueAfter = blue_sdk_1.MathLib.mulDivDown(collateralAfter, price, blue_sdk_1.ORACLE_PRICE_SCALE);
+    const effectiveLltv = lltv > constant_1.DEFAULT_LLTV_BUFFER ? lltv - constant_1.DEFAULT_LLTV_BUFFER : 0n;
+    const maxSafeBorrowAfter = blue_sdk_1.MathLib.wMulDown(collateralValueAfter, effectiveLltv);
+    if (positionData.borrowAssets > maxSafeBorrowAfter) {
+        throw new types_1.WithdrawMakesPositionUnhealthyError({
+            withdrawAmount,
+            borrowAssets: positionData.borrowAssets,
+            maxSafeBorrow: maxSafeBorrowAfter,
+        });
+    }
+};
+exports.validatePositionHealthAfterWithdraw = validatePositionHealthAfterWithdraw;
+/**
+ * Validates that the repay amount assets does not exceed the outstanding debt.
+ *
+ * @param params - Validation parameters.
+ * @param params.positionData - The current accrual position.
+ * @param params.repayAssets - The amount of assets to repay.
+ * @param params.marketId - The market identifier (for error messages).
+ */
+const validateRepayAmount = (params) => {
+    const { positionData, repayAssets, marketId } = params;
+    if (repayAssets > positionData.borrowAssets) {
+        throw new types_1.RepayExceedsDebtError({
+            repayAmount: repayAssets,
+            debt: positionData.borrowAssets,
+            market: marketId,
+        });
+    }
+};
+exports.validateRepayAmount = validateRepayAmount;
+/**
+ * Validates that the repay shares do not exceed the outstanding borrow shares.
+ *
+ * @param params - Validation parameters.
+ * @param params.positionData - The current accrual position.
+ * @param params.repayShares - The amount of shares to repay.
+ * @param params.marketId - The market identifier (for error messages).
+ */
+const validateRepayShares = (params) => {
+    const { positionData, repayShares, marketId } = params;
+    if (repayShares > positionData.borrowShares) {
+        throw new types_1.RepaySharesExceedDebtError({
+            repayShares,
+            borrowShares: positionData.borrowShares,
+            market: marketId,
+        });
+    }
+};
+exports.validateRepayShares = validateRepayShares;
+/**
+ * Validates the common repay input parameters shared by `marketV1Repay`
+ * and `marketV1RepayWithdrawCollateral`.
+ *
+ * @param params - Validation parameters.
+ * @param params.assets - Repay assets amount (0n when repaying by shares).
+ * @param params.shares - Repay shares amount (0n when repaying by assets).
+ * @param params.transferAmount - ERC20 amount to transfer to GeneralAdapter1.
+ * @param params.maxSharePrice - Maximum repay share price (in ray). Must be positive.
+ * @param params.marketId - The market identifier (for error messages).
+ */
+const validateRepayParams = (params) => {
+    const { assets, shares, transferAmount, maxSharePrice, marketId } = params;
+    if (maxSharePrice <= 0n) {
+        throw new types_1.NonPositiveRepayMaxSharePriceError(marketId);
+    }
+    if (assets < 0n || shares < 0n) {
+        throw new types_1.NonPositiveRepayAmountError(marketId);
+    }
+    if (assets > 0n && shares > 0n) {
+        throw new types_1.MutuallyExclusiveRepayAmountsError(marketId);
+    }
+    if (assets === 0n && shares === 0n) {
+        throw new types_1.NonPositiveRepayAmountError(marketId);
+    }
+    if (transferAmount <= 0n) {
+        throw new types_1.NonPositiveTransferAmountError(marketId);
+    }
+    if (assets > 0n && transferAmount !== assets) {
+        throw new types_1.TransferAmountNotEqualToAssetsError({
+            transferAmount,
+            assets,
+            market: marketId,
+        });
+    }
+};
+exports.validateRepayParams = validateRepayParams;
+/**
+ * Validates that vault reallocations are well-formed.
+ *
+ * Enforces the following invariants for each {@link VaultReallocation}:
+ * - `fee` must be non-negative.
+ * - `withdrawals` must be non-empty.
+ * - Every withdrawal `amount` must be strictly positive.
+ * - No withdrawal may target `targetMarketId` (the borrow market).
+ * - Withdrawal market IDs must be strictly ascending (required by `PublicAllocator.reallocateTo`).
+ *
+ * @param reallocations - The reallocations to validate.
+ * @param targetMarketId - The ID of the market being borrowed from. No withdrawal may reference this market.
+ */
+const validateReallocations = (reallocations, targetMarketId) => {
+    for (const r of reallocations) {
+        if (r.fee < 0n) {
+            throw new types_1.NegativeReallocationFeeError(r.vault);
+        }
+        if (r.withdrawals.length === 0) {
+            throw new types_1.EmptyReallocationWithdrawalsError(r.vault);
+        }
+        let prevId;
+        for (const w of r.withdrawals) {
+            if (w.amount <= 0n) {
+                throw new types_1.NonPositiveReallocationAmountError(r.vault, w.marketParams.id);
+            }
+            if (w.marketParams.id === targetMarketId) {
+                throw new types_1.ReallocationWithdrawalOnTargetMarketError(r.vault, w.marketParams.id);
+            }
+            if (prevId !== undefined && w.marketParams.id <= prevId) {
+                throw new types_1.UnsortedReallocationWithdrawalsError(r.vault, w.marketParams.id);
+            }
+            prevId = w.marketParams.id;
+        }
+    }
+};
+exports.validateReallocations = validateReallocations;
+/**
+ * Validates that a slippage tolerance is within an acceptable range.
+ *
+ * Throws {@link NegativeSlippageToleranceError} if negative.
+ * Throws {@link ExcessiveSlippageToleranceError} if greater than {@link MAX_SLIPPAGE_TOLERANCE}.
+ *
+ * @param slippageTolerance - The slippage tolerance in WAD.
+ */
+const validateSlippageTolerance = (slippageTolerance) => {
+    if (slippageTolerance < 0n) {
+        throw new types_1.NegativeSlippageToleranceError(slippageTolerance);
+    }
+    if (slippageTolerance > constant_1.MAX_SLIPPAGE_TOLERANCE) {
+        throw new types_1.ExcessiveSlippageToleranceError(slippageTolerance);
+    }
+};
+exports.validateSlippageTolerance = validateSlippageTolerance;