@morpho-org/consumer-sdk 0.3.0 → 0.5.0

package/lib/entities/vaultV1/vaultV1.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MorphoVaultV1 = void 0;
+const blue_sdk_1 = require("@morpho-org/blue-sdk");
+const blue_sdk_viem_1 = require("@morpho-org/blue-sdk-viem");
+const viem_1 = require("viem");
+const actions_1 = require("../../actions");
+const constant_1 = require("../../helpers/constant");
+const types_1 = require("../../types");
+class MorphoVaultV1 {
+    client;
+    vault;
+    chainId;
+    constructor(client, vault, chainId) {
+        this.client = client;
+        this.vault = vault;
+        this.chainId = chainId;
+    }
+    async getData(parameters) {
+        if (this.client.viemClient.chain?.id &&
+            this.client.viemClient.chain?.id !== this.chainId) {
+            throw new types_1.ChainIdMismatchError(this.client.viemClient.chain?.id, this.chainId);
+        }
+        return (0, blue_sdk_viem_1.fetchAccrualVault)(this.vault, this.client.viemClient, {
+            ...parameters,
+            chainId: this.chainId,
+            deployless: this.client.options.supportDeployless,
+        });
+    }
+    deposit({ amount = 0n, userAddress, accrualVault, slippageTolerance = blue_sdk_1.DEFAULT_SLIPPAGE_TOLERANCE, nativeAmount, }) {
+        if (this.client.viemClient.chain?.id !== this.chainId) {
+            throw new types_1.ChainIdMismatchError(this.client.viemClient.chain?.id, this.chainId);
+        }
+        if (!(0, viem_1.isAddressEqual)(accrualVault.address, this.vault)) {
+            throw new types_1.VaultAddressMismatchError(this.vault, accrualVault.address);
+        }
+        if (amount < 0n) {
+            throw new types_1.NonPositiveAssetAmountError(this.vault);
+        }
+        if (nativeAmount && nativeAmount < 0n) {
+            throw new types_1.NegativeNativeAmountError(nativeAmount);
+        }
+        let wNative;
+        if (nativeAmount) {
+            ({ wNative } = (0, blue_sdk_1.getChainAddresses)(this.chainId));
+            if (!wNative) {
+                throw new types_1.ChainWNativeMissingError(this.chainId);
+            }
+        }
+        if (slippageTolerance < 0n) {
+            throw new types_1.NegativeSlippageToleranceError(slippageTolerance);
+        }
+        if (slippageTolerance > constant_1.MAX_SLIPPAGE_TOLERANCE) {
+            throw new types_1.ExcessiveSlippageToleranceError(slippageTolerance);
+        }
+        if (nativeAmount && wNative) {
+            if (!(0, viem_1.isAddressEqual)(accrualVault.asset, wNative)) {
+                throw new types_1.NativeAmountOnNonWNativeVaultError(accrualVault.asset, wNative);
+            }
+        }
+        const totalAssets = amount + (nativeAmount ?? 0n);
+        const shares = accrualVault.toShares(totalAssets);
+        if (shares <= 0n) {
+            throw new types_1.NonPositiveSharesAmountError(this.vault);
+        }
+        const maxSharePrice = blue_sdk_1.MathLib.min(blue_sdk_1.MathLib.mulDivUp(totalAssets, blue_sdk_1.MathLib.wToRay(blue_sdk_1.MathLib.WAD + slippageTolerance), shares), blue_sdk_1.MathLib.RAY * 100n);
+        return {
+            getRequirements: async (params) => await (0, actions_1.getRequirements)(this.client.viemClient, {
+                address: accrualVault.asset,
+                chainId: this.chainId,
+                supportSignature: this.client.options.supportSignature,
+                supportDeployless: this.client.options.supportDeployless,
+                useSimplePermit: params?.useSimplePermit,
+                args: {
+                    amount,
+                    from: userAddress,
+                },
+            }),
+            buildTx: (requirementSignature) => (0, actions_1.vaultV1Deposit)({
+                vault: {
+                    chainId: this.chainId,
+                    address: this.vault,
+                    asset: accrualVault.asset,
+                },
+                args: {
+                    amount,
+                    maxSharePrice,
+                    recipient: userAddress,
+                    requirementSignature,
+                    nativeAmount,
+                },
+                metadata: this.client.options.metadata,
+            }),
+        };
+    }
+    withdraw({ amount, userAddress }) {
+        if (this.client.viemClient.chain?.id !== this.chainId) {
+            throw new types_1.ChainIdMismatchError(this.client.viemClient.chain?.id, this.chainId);
+        }
+        return {
+            buildTx: () => (0, actions_1.vaultV1Withdraw)({
+                vault: { address: this.vault },
+                args: {
+                    amount,
+                    recipient: userAddress,
+                    onBehalf: userAddress,
+                },
+                metadata: this.client.options.metadata,
+            }),
+        };
+    }
+    redeem({ shares, userAddress }) {
+        if (this.client.viemClient.chain?.id !== this.chainId) {
+            throw new types_1.ChainIdMismatchError(this.client.viemClient.chain?.id, this.chainId);
+        }
+        return {
+            buildTx: () => (0, actions_1.vaultV1Redeem)({
+                vault: { address: this.vault },
+                args: {
+                    shares,
+                    recipient: userAddress,
+                    onBehalf: userAddress,
+                },
+                metadata: this.client.options.metadata,
+            }),
+        };
+    }
+}
+exports.MorphoVaultV1 = MorphoVaultV1;

package/lib/entities/vaultV2/vaultV2.d.ts

@@ -1,6 +1,7 @@
+import { type AccrualVaultV2 } from "@morpho-org/blue-sdk";
 import { fetchAccrualVaultV2 } from "@morpho-org/blue-sdk-viem";
-import type { Address } from "viem";
-import { type Deallocation, type ERC20ApprovalAction, type MorphoClientType, type Requirement, type RequirementSignature, type Transaction, type VaultV2DepositAction, type VaultV2ForceRedeemAction, type VaultV2ForceWithdrawAction, type VaultV2RedeemAction, type VaultV2WithdrawAction } from "../../types";
+import { type Address } from "viem";
+import { type Deallocation, type DepositAmountArgs, type ERC20ApprovalAction, type MorphoClientType, type Requirement, type RequirementSignature, type Transaction, type VaultV2DepositAction, type VaultV2ForceRedeemAction, type VaultV2ForceWithdrawAction, type VaultV2RedeemAction, type VaultV2WithdrawAction } from "../../types";
 import type { FetchParameters } from "../../types/data";
 export interface VaultV2Actions {
     /**
@@ -16,41 +17,43 @@ export interface VaultV2Actions {
      * Prepares a deposit transaction for the VaultV2 contract.
      *
      * This function constructs the transaction data required to deposit a specified amount of assets into the vault.
-     * The function asynchronously fetches the latest vault data to ensure accurate calculations for slippage and asset address,
+     * Uses pre-fetched accrual vault data for accurate calculations of slippage and asset address,
      * then returns the prepared deposit transaction and a function for retrieving all required approval transactions.
      * Bundler Integration: This flow uses the bundler to atomically execute the user's asset transfer and vault deposit in a single transaction for slippage protection.
      *
      * @param {Object} params - The deposit parameters.
-     * @param {bigint} params.assets - The amount of assets to deposit.
-     * @param {Address} [params.userAddress] - Optional user address initiating the deposit. Default is the client's user address is used.
+     * @param {bigint} [params.amount=0n] - Amount of ERC-20 assets to deposit. At least one of amount or nativeAmount must be provided.
+     * @param {Address} params.userAddress - User address initiating the deposit.
+     * @param {AccrualVaultV2} params.accrualVault - Pre-fetched vault data with asset address and share conversion.
      * @param {bigint} [params.slippageTolerance=DEFAULT_SLIPPAGE_TOLERANCE] - Optional slippage tolerance value. Default is 0.03%. Slippage tolerance must be less than 10%.
+     * @param {bigint} [params.nativeAmount] - Amount of native token to wrap into wNative. Vault asset must be wNative.
      * @returns {Object} The result object.
      * @returns {Readonly<Transaction<VaultV2DepositAction>>} returns.tx The prepared deposit transaction.
-     * @returns {Promise<Readonly<Transaction<ERC20ApprovalAction>[]>>} returns.getRequirements The function for retrieving all required approval transactions.
+     * @returns {Promise<(Readonly<Transaction<ERC20ApprovalAction>> | Requirement)[]>} returns.getRequirements The function for retrieving all required approval transactions.
      */
     deposit: (params: {
-        assets: bigint;
         userAddress: Address;
+        accrualVault: AccrualVaultV2;
         slippageTolerance?: bigint;
-    }) => Promise<{
+    } & DepositAmountArgs) => {
         buildTx: (requirementSignature?: RequirementSignature) => Readonly<Transaction<VaultV2DepositAction>>;
         getRequirements: (params?: {
             useSimplePermit?: boolean;
         }) => Promise<(Readonly<Transaction<ERC20ApprovalAction>> | Requirement)[]>;
-    }>;
+    };
     /**
      * Prepares a withdraw transaction for the VaultV2 contract.
      *
      * This function constructs the transaction data required to withdraw a specified amount of assets from the vault.
      *
      * @param {Object} params - The withdraw parameters.
-     * @param {bigint} params.assets - The amount of assets to withdraw.
+     * @param {bigint} params.amount - The amount of assets to withdraw.
      * @param {Address} params.userAddress - User address initiating the withdraw.
      * @returns {Object} The result object.
      * @returns {Readonly<Transaction<VaultV2WithdrawAction>>} returns.tx The prepared withdraw transaction.
      */
     withdraw: (params: {
-        assets: bigint;
+        amount: bigint;
         userAddress: Address;
     }) => {
         buildTx: () => Readonly<Transaction<VaultV2WithdrawAction>>;
@@ -82,7 +85,7 @@ export interface VaultV2Actions {
      * @param {Object} params - The force withdraw parameters.
      * @param {readonly Deallocation[]} params.deallocations - The typed list of deallocations to perform.
      * @param {Object} params.withdraw - The withdraw parameters applied after deallocations.
-     * @param {bigint} params.withdraw.assets - The amount of assets to withdraw.
+     * @param {bigint} params.withdraw.amount - The amount of assets to withdraw.
      * @param {Address} params.userAddress - User address (penalty source and withdraw recipient).
      * @returns {Object} The result object.
      * @returns {Readonly<Transaction<VaultV2ForceWithdrawAction>>} returns.buildTx The prepared multicall transaction.
@@ -90,7 +93,7 @@ export interface VaultV2Actions {
     forceWithdraw: (params: {
         deallocations: readonly Deallocation[];
         withdraw: {
-            assets: bigint;
+            amount: bigint;
         };
         userAddress: Address;
     }) => {
@@ -133,19 +136,19 @@ export declare class MorphoVaultV2 implements VaultV2Actions {
     private readonly vault;
     private readonly chainId;
     constructor(client: MorphoClientType, vault: Address, chainId: number);
-    getData(parameters?: FetchParameters): Promise<import("@morpho-org/blue-sdk").AccrualVaultV2>;
-    deposit({ assets, userAddress, slippageTolerance, }: {
-        assets: bigint;
+    getData(parameters?: FetchParameters): Promise<AccrualVaultV2>;
+    deposit({ amount, userAddress, accrualVault, slippageTolerance, nativeAmount, }: {
         userAddress: Address;
+        accrualVault: AccrualVaultV2;
         slippageTolerance?: bigint;
-    }): Promise<{
+    } & DepositAmountArgs): {
         getRequirements: (params?: {
             useSimplePermit?: boolean;
         }) => Promise<(Requirement | Readonly<Transaction<ERC20ApprovalAction>>)[]>;
         buildTx: (requirementSignature?: RequirementSignature) => Readonly<Transaction<VaultV2DepositAction>>;
-    }>;
-    withdraw({ assets, userAddress }: {
-        assets: bigint;
+    };
+    withdraw({ amount, userAddress }: {
+        amount: bigint;
         userAddress: Address;
     }): {
         buildTx: () => Readonly<Transaction<VaultV2WithdrawAction>>;
@@ -159,7 +162,7 @@ export declare class MorphoVaultV2 implements VaultV2Actions {
     forceWithdraw({ deallocations, withdraw, userAddress, }: {
         deallocations: readonly Deallocation[];
         withdraw: {
-            assets: bigint;
+            amount: bigint;
         };
         userAddress: Address;
     }): {

package/lib/entities/vaultV2/vaultV2.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MorphoVaultV2 = void 0;
 const blue_sdk_1 = require("@morpho-org/blue-sdk");
 const blue_sdk_viem_1 = require("@morpho-org/blue-sdk-viem");
+const viem_1 = require("viem");
 const actions_1 = require("../../actions");
 const constant_1 = require("../../helpers/constant");
 const types_1 = require("../../types");
@@ -16,37 +17,62 @@ class MorphoVaultV2 {
         this.chainId = chainId;
     }
     async getData(parameters) {
+        if (this.client.viemClient.chain?.id &&
+            this.client.viemClient.chain?.id !== this.chainId) {
+            throw new types_1.ChainIdMismatchError(this.client.viemClient.chain?.id, this.chainId);
+        }
         return (0, blue_sdk_viem_1.fetchAccrualVaultV2)(this.vault, this.client.viemClient, {
             ...parameters,
             chainId: this.chainId,
             deployless: this.client.options.supportDeployless,
         });
     }
-    async deposit({ assets, userAddress, slippageTolerance = blue_sdk_1.DEFAULT_SLIPPAGE_TOLERANCE, }) {
+    deposit({ amount = 0n, userAddress, accrualVault, slippageTolerance = blue_sdk_1.DEFAULT_SLIPPAGE_TOLERANCE, nativeAmount, }) {
         if (this.client.viemClient.chain?.id !== this.chainId) {
             throw new types_1.ChainIdMismatchError(this.client.viemClient.chain?.id, this.chainId);
         }
-        const vaultData = await (0, blue_sdk_viem_1.fetchVaultV2)(this.vault, this.client.viemClient, {
-            chainId: this.chainId,
-            deployless: this.client.options.supportDeployless,
-        });
+        if (!(0, viem_1.isAddressEqual)(accrualVault.address, this.vault)) {
+            throw new types_1.VaultAddressMismatchError(this.vault, accrualVault.address);
+        }
+        if (amount < 0n) {
+            throw new types_1.NonPositiveAssetAmountError(this.vault);
+        }
+        if (nativeAmount && nativeAmount < 0n) {
+            throw new types_1.NegativeNativeAmountError(nativeAmount);
+        }
+        let wNative;
+        if (nativeAmount) {
+            ({ wNative } = (0, blue_sdk_1.getChainAddresses)(this.chainId));
+            if (!wNative) {
+                throw new types_1.ChainWNativeMissingError(this.chainId);
+            }
+        }
+        if (slippageTolerance < 0n) {
+            throw new types_1.NegativeSlippageToleranceError(slippageTolerance);
+        }
         if (slippageTolerance > constant_1.MAX_SLIPPAGE_TOLERANCE) {
             throw new types_1.ExcessiveSlippageToleranceError(slippageTolerance);
         }
-        const shares = vaultData.toShares(assets);
-        if (shares === 0n) {
-            throw new types_1.ZeroSharesAmountError(this.vault);
+        if (nativeAmount && wNative) {
+            if (!(0, viem_1.isAddressEqual)(accrualVault.asset, wNative)) {
+                throw new types_1.NativeAmountOnNonWNativeVaultError(accrualVault.asset, wNative);
+            }
+        }
+        const totalAssets = amount + (nativeAmount ?? 0n);
+        const shares = accrualVault.toShares(totalAssets);
+        if (shares <= 0n) {
+            throw new types_1.NonPositiveSharesAmountError(this.vault);
         }
-        const maxSharePrice = blue_sdk_1.MathLib.min(blue_sdk_1.MathLib.mulDivUp(assets, blue_sdk_1.MathLib.wToRay(blue_sdk_1.MathLib.WAD + slippageTolerance), shares), blue_sdk_1.MathLib.RAY * 100n);
+        const maxSharePrice = blue_sdk_1.MathLib.min(blue_sdk_1.MathLib.mulDivUp(totalAssets, blue_sdk_1.MathLib.wToRay(blue_sdk_1.MathLib.WAD + slippageTolerance), shares), blue_sdk_1.MathLib.RAY * 100n);
         return {
             getRequirements: async (params) => await (0, actions_1.getRequirements)(this.client.viemClient, {
-                address: vaultData.asset,
+                address: accrualVault.asset,
                 chainId: this.chainId,
                 supportSignature: this.client.options.supportSignature,
                 supportDeployless: this.client.options.supportDeployless,
                 useSimplePermit: params?.useSimplePermit,
                 args: {
-                    amount: assets,
+                    amount,
                     from: userAddress,
                 },
             }),
@@ -54,19 +80,20 @@ class MorphoVaultV2 {
                 vault: {
                     chainId: this.chainId,
                     address: this.vault,
-                    asset: vaultData.asset,
+                    asset: accrualVault.asset,
                 },
                 args: {
-                    assets,
+                    amount,
                     maxSharePrice,
                     recipient: userAddress,
                     requirementSignature,
+                    nativeAmount,
                 },
                 metadata: this.client.options.metadata,
             }),
         };
     }
-    withdraw({ assets, userAddress }) {
+    withdraw({ amount, userAddress }) {
         if (this.client.viemClient.chain?.id !== this.chainId) {
             throw new types_1.ChainIdMismatchError(this.client.viemClient.chain?.id, this.chainId);
         }
@@ -74,7 +101,7 @@ class MorphoVaultV2 {
             buildTx: () => (0, actions_1.vaultV2Withdraw)({
                 vault: { address: this.vault },
                 args: {
-                    assets,
+                    amount,
                     recipient: userAddress,
                     onBehalf: userAddress,
                 },
@@ -108,7 +135,7 @@ class MorphoVaultV2 {
                 args: {
                     deallocations,
                     withdraw: {
-                        assets: withdraw.assets,
+                        amount: withdraw.amount,
                         recipient: userAddress,
                     },
                     onBehalf: userAddress,

package/lib/helpers/computeReallocations.d.ts

@@ -0,0 +1,23 @@
+import { type MarketId } from "@morpho-org/blue-sdk";
+import type { SimulationState } from "@morpho-org/simulation-sdk";
+import { type ReallocationComputeOptions, type VaultReallocation } from "../types";
+/**
+ * Computes vault reallocations for a borrow operation on a target market.
+ *
+ * Replicates the shared liquidity algorithm from `populateSubBundle` in
+ * `@morpho-org/bundler-sdk-viem`. First attempts "friendly" reallocations
+ * respecting withdrawal utilization targets, then falls back to aggressive
+ * reallocations (100% withdrawal utilization) if liquidity is still insufficient.
+ *
+ * @param params.reallocationData - The simulation state containing market, vault, and position data.
+ * @param params.marketId - The target market to reallocate liquidity into.
+ * @param params.borrowAmount - The intended borrow amount (used to compute post-borrow utilization).
+ * @param params.options - Optional reallocation computation options.
+ * @returns Array of vault reallocations, sorted with withdrawals in ascending market id order.
+ */
+export declare const computeReallocations: ({ reallocationData: data, marketId, borrowAmount, options, }: {
+    readonly reallocationData: SimulationState;
+    readonly marketId: MarketId;
+    readonly borrowAmount: bigint;
+    readonly options?: ReallocationComputeOptions;
+}) => readonly VaultReallocation[];

package/lib/helpers/computeReallocations.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeReallocations = void 0;
+const blue_sdk_1 = require("@morpho-org/blue-sdk");
+const bundler_sdk_viem_1 = require("@morpho-org/bundler-sdk-viem");
+const types_1 = require("../types");
+/**
+ * Computes vault reallocations for a borrow operation on a target market.
+ *
+ * Replicates the shared liquidity algorithm from `populateSubBundle` in
+ * `@morpho-org/bundler-sdk-viem`. First attempts "friendly" reallocations
+ * respecting withdrawal utilization targets, then falls back to aggressive
+ * reallocations (100% withdrawal utilization) if liquidity is still insufficient.
+ *
+ * @param params.reallocationData - The simulation state containing market, vault, and position data.
+ * @param params.marketId - The target market to reallocate liquidity into.
+ * @param params.borrowAmount - The intended borrow amount (used to compute post-borrow utilization).
+ * @param params.options - Optional reallocation computation options.
+ * @returns Array of vault reallocations, sorted with withdrawals in ascending market id order.
+ */
+const computeReallocations = ({ reallocationData: data, marketId, borrowAmount, options, }) => {
+    if (options?.enabled === false)
+        return [];
+    const market = data.getMarket(marketId).accrueInterest(data.block.timestamp);
+    const newTotalBorrowAssets = market.totalBorrowAssets + borrowAmount;
+    const newTotalSupplyAssets = market.totalSupplyAssets;
+    const supplyTargetUtilization = options?.supplyTargetUtilization?.[market.params.id] ??
+        options?.defaultSupplyTargetUtilization ??
+        bundler_sdk_viem_1.DEFAULT_SUPPLY_TARGET_UTILIZATION;
+    if (blue_sdk_1.MarketUtils.getUtilization({
+        totalSupplyAssets: newTotalSupplyAssets,
+        totalBorrowAssets: newTotalBorrowAssets,
+    }) <= supplyTargetUtilization)
+        return [];
+    // Solve: newTotalBorrowAssets / (newTotalSupplyAssets + reallocatedAssets) = supplyTargetUtilization
+    let requiredAssets = supplyTargetUtilization === 0n
+        ? blue_sdk_1.MathLib.MAX_UINT_160
+        : blue_sdk_1.MathLib.wDivDown(newTotalBorrowAssets, supplyTargetUtilization) -
+            newTotalSupplyAssets;
+    // Phase 1: "friendly" reallocations respecting withdrawal utilization targets.
+    const { withdrawals: friendlyWithdrawals, data: friendlyReallocationData } = data.getMarketPublicReallocations(market.id, options);
+    const withdrawals = [...friendlyWithdrawals];
+    const friendlyReallocationMarket = friendlyReallocationData.getMarket(market.id);
+    if (friendlyReallocationMarket.totalBorrowAssets + borrowAmount >
+        friendlyReallocationMarket.totalSupplyAssets) {
+        // Phase 2: "aggressive" — fully withdraw from every market (100% utilization).
+        requiredAssets = newTotalBorrowAssets - newTotalSupplyAssets;
+        withdrawals.push(...friendlyReallocationData.getMarketPublicReallocations(market.id, {
+            ...options,
+            defaultMaxWithdrawalUtilization: blue_sdk_1.MathLib.WAD,
+            maxWithdrawalUtilization: {},
+        }).withdrawals);
+    }
+    if (requiredAssets <= 0n)
+        return [];
+    // Group withdrawals by vault, capping total at requiredAssets.
+    const reallocationsMap = {};
+    for (const { vault, ...withdrawal } of withdrawals) {
+        const vaultReallocations = (reallocationsMap[vault] ??= []);
+        const existing = vaultReallocations.find((item) => item.id === withdrawal.id);
+        const reallocatedAssets = blue_sdk_1.MathLib.min(withdrawal.assets, requiredAssets);
+        if (reallocatedAssets <= 0n)
+            continue;
+        if (existing != null) {
+            existing.assets += reallocatedAssets;
+        }
+        else {
+            vaultReallocations.push({
+                ...withdrawal,
+                assets: reallocatedAssets,
+            });
+        }
+        requiredAssets -= reallocatedAssets;
+        if (requiredAssets === 0n)
+            break;
+    }
+    // Transform into VaultReallocation[] format.
+    return Object.entries(reallocationsMap)
+        .filter(([, vaultWithdrawals]) => vaultWithdrawals.length > 0)
+        .map(([vault, vaultWithdrawals]) => ({
+        vault: vault,
+        fee: (() => {
+            const config = data.getVault(vault).publicAllocatorConfig;
+            if (config == null) {
+                throw new types_1.MissingPublicAllocatorConfigError(vault);
+            }
+            return config.fee;
+        })(),
+        withdrawals: vaultWithdrawals
+            // Reallocation withdrawals must be sorted by market id in ascending order.
+            .sort(({ id: idA }, { id: idB }) => idA > idB ? 1 : idA < idB ? -1 : 0)
+            .map(({ id, assets }) => ({
+            marketParams: data.getMarket(id).params,
+            amount: assets,
+        })),
+    }));
+};
+exports.computeReallocations = computeReallocations;

package/lib/helpers/constant.d.ts

@@ -1 +1,6 @@
+/** Maximum slippage tolerance: 10% */
 export declare const MAX_SLIPPAGE_TOLERANCE: bigint;
+/** Default LLTV buffer: 0.5% below LLTV. Prevents instant liquidation on new positions. */
+export declare const DEFAULT_LLTV_BUFFER: bigint;
+/** Maximum absolute share price cap (100 RAY). Prevents absurd maxSharePrice values in repay. */
+export declare const MAX_ABSOLUTE_SHARE_PRICE: bigint;

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/encodeDeallocation.js

@@ -25,13 +25,13 @@ function encodeDeallocateData(deallocation) {
  * @returns The ABI-encoded calldata for `VaultV2.forceDeallocate`.
  */
 function encodeForceDeallocateCall(deallocation, onBehalf) {
-    if (deallocation.assets === 0n) {
-        throw new types_1.ZeroAssetAmountError(deallocation.adapter);
+    if (deallocation.amount <= 0n) {
+        throw new types_1.NonPositiveAssetAmountError(deallocation.adapter);
     }
     const data = encodeDeallocateData(deallocation);
     return (0, viem_1.encodeFunctionData)({
         abi: blue_sdk_viem_1.vaultV2Abi,
         functionName: "forceDeallocate",
-        args: [deallocation.adapter, data, deallocation.assets, onBehalf],
+        args: [deallocation.adapter, data, deallocation.amount, onBehalf],
     });
 }

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;