@morpho-org/consumer-sdk 0.2.0 → 0.4.0

package/lib/actions/vaultV1/withdraw.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vaultV1Withdraw = void 0;
+const blue_sdk_viem_1 = require("@morpho-org/blue-sdk-viem");
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+const viem_1 = require("viem");
+const helpers_1 = require("../../helpers");
+const types_1 = require("../../types");
+/**
+ * Prepares a withdraw transaction for a VaultV1 (MetaMorpho) contract.
+ *
+ * Direct vault call — no bundler needed. Withdraw has no inflation attack surface.
+ *
+ * @param {Object} params - The withdraw parameters.
+ * @param {Object} params.vault - The vault identifiers.
+ * @param {Address} params.vault.address - The vault address.
+ * @param {Object} params.args - The withdraw arguments.
+ * @param {bigint} params.args.amount - Amount of assets to withdraw.
+ * @param {Address} params.args.recipient - Receives the withdrawn assets.
+ * @param {Address} params.args.onBehalf - Address whose shares are burned.
+ * @param {Metadata} [params.metadata] - Optional analytics metadata.
+ * @returns {Readonly<Transaction<VaultV1WithdrawAction>>} The prepared withdraw transaction.
+ */
+const vaultV1Withdraw = ({ vault: { address: vaultAddress }, args: { amount, recipient, onBehalf }, metadata, }) => {
+    if (amount <= 0n) {
+        throw new types_1.NonPositiveAssetAmountError(vaultAddress);
+    }
+    let tx = {
+        to: vaultAddress,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: blue_sdk_viem_1.metaMorphoAbi,
+            functionName: "withdraw",
+            args: [amount, recipient, onBehalf],
+        }),
+        value: 0n,
+    };
+    if (metadata) {
+        tx = (0, helpers_1.addTransactionMetadata)(tx, metadata);
+    }
+    return (0, morpho_ts_1.deepFreeze)({
+        ...tx,
+        action: {
+            type: "vaultV1Withdraw",
+            args: { vault: vaultAddress, amount, recipient },
+        },
+    });
+};
+exports.vaultV1Withdraw = vaultV1Withdraw;

package/lib/actions/vaultV2/deposit.d.ts

@@ -1,13 +1,12 @@
-import type { Address } from "viem";
-import { type Metadata, type RequirementSignature, type Transaction, type VaultV2DepositAction } from "../../types";
+import { type Address } from "viem";
+import { type DepositAmountArgs, type Metadata, type RequirementSignature, type Transaction, type VaultV2DepositAction } from "../../types";
 export interface VaultV2DepositParams {
     vault: {
         chainId: number;
         address: Address;
         asset: Address;
     };
-    args: {
-        assets: bigint;
+    args: DepositAmountArgs & {
         maxSharePrice: bigint;
         recipient: Address;
         requirementSignature?: RequirementSignature;
@@ -17,30 +16,26 @@ export interface VaultV2DepositParams {
 /**
  * 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.
- * 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.
+ * Routed through the bundler to atomically execute the asset transfer and vault deposit.
+ * The general adapter enforces `maxSharePrice` on-chain to prevent inflation attacks.
+ * Never bypass the general adapter.
  *
- * IMPORTANT FOR DEVELOPERS:
- * This deposit flow is routed through the general adapter in order to enforce a strict check on `maxSharePrice`.
- * This check is critical to prevent inflation attacks, especially for vaults where there is no "dead deposit" protection.
- * Do not bypass the general adapter or remove this check, as doing so would expose the flow to potential exploits.
- * The maxSharePrice constraint ensures that the user does not receive unfavorable share pricing due to malicious or sudden vault changes.
+ * When `nativeAmount` is provided, that amount of native ETH is sent as `msg.value`
+ * to the Bundler3 multicall and wrapped into WETH via `GeneralAdapter1.wrapNative()`.
+ * The vault's underlying asset must be the chain's wrapped native token (wNative).
  *
- *
- * @param {Object} params - The vault related parameters.
- * @param {Object} params.vault - The vault related parameters.
+ * @param {Object} params - The deposit parameters.
+ * @param {Object} params.vault - The vault identifiers.
  * @param {number} params.vault.chainId - The chain ID.
  * @param {Address} params.vault.address - The vault address.
- * @param {Address} params.vault.asset - The vault asset address.
- * @param {Object} params.args - The deposit related parameters.
- * @param {bigint} params.args.assets - The amount of assets to deposit.
- * @param {bigint} params.args.maxSharePrice - The maximum share price to accept for the deposit.
- * @param {Address} params.args.recipient - The recipient address.
- * @param {Object} params.args.requirementSignature - The requirement args and signature.
- * @param {Object} params.args.requirementSignature.args - The requirement signature arguments.
- * @param {Object} params.args.requirementSignature.action - The requirement signature action.
- * @param {Metadata} [params.metadata] - Optional the metadata.
- *
+ * @param {Address} params.vault.asset - The underlying ERC20 asset address.
+ * @param {Object} params.args - The deposit arguments.
+ * @param {bigint} [params.args.amount=0n] - Amount of ERC-20 assets to deposit. At least one of amount or nativeAmount must be provided.
+ * @param {bigint} params.args.maxSharePrice - Maximum acceptable share price (slippage protection).
+ * @param {Address} params.args.recipient - Receives the vault shares.
+ * @param {RequirementSignature} [params.args.requirementSignature] - Pre-signed permit/permit2 approval.
+ * @param {bigint} [params.args.nativeAmount] - Amount of native token to wrap into wNative for the deposit.
+ * @param {Metadata} [params.metadata] - Optional analytics metadata.
  * @returns {Readonly<Transaction<VaultV2DepositAction>>} The prepared deposit transaction.
  */
-export declare const vaultV2Deposit: ({ vault: { chainId, address: vaultAddress, asset }, args: { assets, maxSharePrice, recipient, requirementSignature }, metadata, }: VaultV2DepositParams) => Readonly<Transaction<VaultV2DepositAction>>;
+export declare const vaultV2Deposit: ({ vault: { chainId, address: vaultAddress, asset }, args: { amount, maxSharePrice, recipient, requirementSignature, nativeAmount, }, metadata, }: VaultV2DepositParams) => Readonly<Transaction<VaultV2DepositAction>>;

package/lib/actions/vaultV2/deposit.js

@@ -4,66 +4,98 @@ exports.vaultV2Deposit = void 0;
 const blue_sdk_1 = require("@morpho-org/blue-sdk");
 const bundler_sdk_viem_1 = require("@morpho-org/bundler-sdk-viem");
 const morpho_ts_1 = require("@morpho-org/morpho-ts");
+const viem_1 = require("viem");
 const helpers_1 = require("../../helpers");
 const types_1 = require("../../types");
 const getRequirementsAction_1 = require("../requirements/getRequirementsAction");
 /**
  * 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.
- * 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.
+ * Routed through the bundler to atomically execute the asset transfer and vault deposit.
+ * The general adapter enforces `maxSharePrice` on-chain to prevent inflation attacks.
+ * Never bypass the general adapter.
  *
- * IMPORTANT FOR DEVELOPERS:
- * This deposit flow is routed through the general adapter in order to enforce a strict check on `maxSharePrice`.
- * This check is critical to prevent inflation attacks, especially for vaults where there is no "dead deposit" protection.
- * Do not bypass the general adapter or remove this check, as doing so would expose the flow to potential exploits.
- * The maxSharePrice constraint ensures that the user does not receive unfavorable share pricing due to malicious or sudden vault changes.
+ * When `nativeAmount` is provided, that amount of native ETH is sent as `msg.value`
+ * to the Bundler3 multicall and wrapped into WETH via `GeneralAdapter1.wrapNative()`.
+ * The vault's underlying asset must be the chain's wrapped native token (wNative).
  *
- *
- * @param {Object} params - The vault related parameters.
- * @param {Object} params.vault - The vault related parameters.
+ * @param {Object} params - The deposit parameters.
+ * @param {Object} params.vault - The vault identifiers.
  * @param {number} params.vault.chainId - The chain ID.
  * @param {Address} params.vault.address - The vault address.
- * @param {Address} params.vault.asset - The vault asset address.
- * @param {Object} params.args - The deposit related parameters.
- * @param {bigint} params.args.assets - The amount of assets to deposit.
- * @param {bigint} params.args.maxSharePrice - The maximum share price to accept for the deposit.
- * @param {Address} params.args.recipient - The recipient address.
- * @param {Object} params.args.requirementSignature - The requirement args and signature.
- * @param {Object} params.args.requirementSignature.args - The requirement signature arguments.
- * @param {Object} params.args.requirementSignature.action - The requirement signature action.
- * @param {Metadata} [params.metadata] - Optional the metadata.
- *
+ * @param {Address} params.vault.asset - The underlying ERC20 asset address.
+ * @param {Object} params.args - The deposit arguments.
+ * @param {bigint} [params.args.amount=0n] - Amount of ERC-20 assets to deposit. At least one of amount or nativeAmount must be provided.
+ * @param {bigint} params.args.maxSharePrice - Maximum acceptable share price (slippage protection).
+ * @param {Address} params.args.recipient - Receives the vault shares.
+ * @param {RequirementSignature} [params.args.requirementSignature] - Pre-signed permit/permit2 approval.
+ * @param {bigint} [params.args.nativeAmount] - Amount of native token to wrap into wNative for the deposit.
+ * @param {Metadata} [params.metadata] - Optional analytics metadata.
  * @returns {Readonly<Transaction<VaultV2DepositAction>>} The prepared deposit transaction.
  */
-const vaultV2Deposit = ({ vault: { chainId, address: vaultAddress, asset }, args: { assets, maxSharePrice, recipient, requirementSignature }, metadata, }) => {
-    if (assets === 0n) {
-        throw new types_1.ZeroAssetAmountError(asset);
+const vaultV2Deposit = ({ vault: { chainId, address: vaultAddress, asset }, args: { amount = 0n, maxSharePrice, recipient, requirementSignature, nativeAmount, }, metadata, }) => {
+    if (amount < 0n) {
+        throw new types_1.NonPositiveAssetAmountError(asset);
     }
-    if (maxSharePrice === 0n) {
-        throw new types_1.ZeroMaxSharePriceError(vaultAddress);
+    if (maxSharePrice <= 0n) {
+        throw new types_1.NonPositiveMaxSharePriceError(vaultAddress);
     }
     const actions = [];
-    if (requirementSignature) {
-        actions.push(...(0, getRequirementsAction_1.getRequirementsAction)({
-            chainId,
-            asset,
-            assets,
-            requirementSignature,
-        }));
-    }
-    else {
-        const { bundler3: { generalAdapter1 }, } = (0, blue_sdk_1.getChainAddresses)(chainId);
-        actions.push({
-            type: "erc20TransferFrom",
-            args: [asset, assets, generalAdapter1, false],
+    const { bundler3: { generalAdapter1, bundler3 }, wNative, } = (0, blue_sdk_1.getChainAddresses)(chainId);
+    if (nativeAmount) {
+        if (nativeAmount < 0n) {
+            throw new types_1.NegativeNativeAmountError(nativeAmount);
+        }
+        if (!(0, morpho_ts_1.isDefined)(wNative)) {
+            throw new types_1.ChainWNativeMissingError(chainId);
+        }
+        if (!(0, viem_1.isAddressEqual)(asset, wNative)) {
+            throw new types_1.NativeAmountOnNonWNativeVaultError(asset, wNative);
+        }
+        actions.push(
+        // Transfers native token from Bundler3 to GeneralAdapter1 for wrapping.
+        {
+            type: "nativeTransfer",
+            args: [bundler3, generalAdapter1, nativeAmount, false /* skipRevert */],
+        }, {
+            type: "wrapNative",
+            args: [nativeAmount, generalAdapter1, false /* skipRevert */],
         });
     }
+    if (amount > 0n) {
+        if (requirementSignature) {
+            actions.push(...(0, getRequirementsAction_1.getRequirementsAction)({
+                chainId,
+                asset,
+                amount,
+                requirementSignature,
+            }));
+        }
+        else {
+            actions.push({
+                type: "erc20TransferFrom",
+                args: [asset, amount, generalAdapter1, false /* skipRevert */],
+            });
+        }
+    }
+    const totalAssets = amount + (nativeAmount ?? 0n);
+    if (totalAssets === 0n) {
+        throw new types_1.ZeroDepositAmountError(vaultAddress);
+    }
     actions.push({
         type: "erc4626Deposit",
-        args: [vaultAddress, assets, maxSharePrice, recipient, false],
+        args: [
+            vaultAddress,
+            totalAssets,
+            maxSharePrice,
+            recipient,
+            false /* skipRevert */,
+        ],
     });
     let tx = bundler_sdk_viem_1.BundlerAction.encodeBundle(chainId, actions);
+    if (nativeAmount) {
+        tx = { ...tx, value: nativeAmount };
+    }
     if (metadata) {
         tx = (0, helpers_1.addTransactionMetadata)(tx, metadata);
     }
@@ -71,7 +103,13 @@ const vaultV2Deposit = ({ vault: { chainId, address: vaultAddress, asset }, args
         ...tx,
         action: {
             type: "vaultV2Deposit",
-            args: { vault: vaultAddress, assets, maxSharePrice, recipient },
+            args: {
+                vault: vaultAddress,
+                amount,
+                maxSharePrice,
+                recipient,
+                nativeAmount,
+            },
         },
     });
 };

package/lib/actions/vaultV2/forceRedeem.d.ts

@@ -0,0 +1,48 @@
+import { type Address } from "viem";
+import { type Deallocation, type Metadata, type Transaction, type VaultV2ForceRedeemAction } from "../../types";
+export interface VaultV2ForceRedeemParams {
+    vault: {
+        address: Address;
+    };
+    args: {
+        deallocations: readonly Deallocation[];
+        redeem: {
+            shares: bigint;
+            recipient: Address;
+        };
+        onBehalf: Address;
+    };
+    metadata?: Metadata;
+}
+/**
+ * Prepares a force redeem transaction for the VaultV2 contract, using VaultV2's native `multicall`.
+ *
+ * This function encodes one or more `forceDeallocate` calls followed by a single `redeem`,
+ * executed atomically via VaultV2's `multicall`. This allows a user to free liquidity from
+ * adapters other than the liquidity adapter and redeem all their shares in one transaction.
+
+ *
+ * This is the share-based counterpart to `vaultV2ForceWithdraw`, useful when the user wants
+ * to redeem a maximum amount of shares rather than specifying an exact asset amount.
+ *
+ * The total assets passed to `forceDeallocate` calls must be greater than or equal to the
+ * asset-equivalent of the redeemed shares. The caller should apply a buffer on the deallocated
+ * amounts to account for share-price drift between submission and execution.
+ *
+ * A penalty is taken from `onBehalf` for each deallocation to discourage allocation manipulations.
+ * The penalty is applied as a share burn where assets are returned to the vault, so the share price
+ * remains stable (except for rounding).
+ *
+ * @param {Object} params - The vault related parameters.
+ * @param {Object} params.vault - The vault related parameters.
+ * @param {Address} params.vault.address - The vault contract address.
+ * @param {Object} params.args - The force redeem related parameters.
+ * @param {readonly Deallocation[]} params.args.deallocations - The list of deallocations to perform.
+ * @param {Object} params.args.redeem - The redeem parameters applied after deallocations.
+ * @param {bigint} params.args.redeem.shares - The amount of shares to redeem.
+ * @param {Address} params.args.redeem.recipient - The recipient of the redeemed assets.
+ * @param {Address} params.args.onBehalf - The address from which the penalty is taken (share owner).
+ * @param {Metadata} [params.metadata] - Optional analytics metadata to append.
+ * @returns {Readonly<Transaction<VaultV2ForceRedeemAction>>} The prepared multicall transaction.
+ */
+export declare const vaultV2ForceRedeem: ({ vault: { address: vaultAddress }, args: { deallocations, redeem, onBehalf }, metadata, }: VaultV2ForceRedeemParams) => Readonly<Transaction<VaultV2ForceRedeemAction>>;

package/lib/actions/vaultV2/forceRedeem.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vaultV2ForceRedeem = void 0;
+const blue_sdk_viem_1 = require("@morpho-org/blue-sdk-viem");
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+const viem_1 = require("viem");
+const helpers_1 = require("../../helpers");
+const encodeDeallocation_1 = require("../../helpers/encodeDeallocation");
+const types_1 = require("../../types");
+/**
+ * Prepares a force redeem transaction for the VaultV2 contract, using VaultV2's native `multicall`.
+ *
+ * This function encodes one or more `forceDeallocate` calls followed by a single `redeem`,
+ * executed atomically via VaultV2's `multicall`. This allows a user to free liquidity from
+ * adapters other than the liquidity adapter and redeem all their shares in one transaction.
+
+ *
+ * This is the share-based counterpart to `vaultV2ForceWithdraw`, useful when the user wants
+ * to redeem a maximum amount of shares rather than specifying an exact asset amount.
+ *
+ * The total assets passed to `forceDeallocate` calls must be greater than or equal to the
+ * asset-equivalent of the redeemed shares. The caller should apply a buffer on the deallocated
+ * amounts to account for share-price drift between submission and execution.
+ *
+ * A penalty is taken from `onBehalf` for each deallocation to discourage allocation manipulations.
+ * The penalty is applied as a share burn where assets are returned to the vault, so the share price
+ * remains stable (except for rounding).
+ *
+ * @param {Object} params - The vault related parameters.
+ * @param {Object} params.vault - The vault related parameters.
+ * @param {Address} params.vault.address - The vault contract address.
+ * @param {Object} params.args - The force redeem related parameters.
+ * @param {readonly Deallocation[]} params.args.deallocations - The list of deallocations to perform.
+ * @param {Object} params.args.redeem - The redeem parameters applied after deallocations.
+ * @param {bigint} params.args.redeem.shares - The amount of shares to redeem.
+ * @param {Address} params.args.redeem.recipient - The recipient of the redeemed assets.
+ * @param {Address} params.args.onBehalf - The address from which the penalty is taken (share owner).
+ * @param {Metadata} [params.metadata] - Optional analytics metadata to append.
+ * @returns {Readonly<Transaction<VaultV2ForceRedeemAction>>} The prepared multicall transaction.
+ */
+const vaultV2ForceRedeem = ({ vault: { address: vaultAddress }, args: { deallocations, redeem, onBehalf }, metadata, }) => {
+    if (deallocations.length === 0) {
+        throw new types_1.EmptyDeallocationsError(vaultAddress);
+    }
+    if (redeem.shares <= 0n) {
+        throw new types_1.NonPositiveSharesAmountError(vaultAddress);
+    }
+    const calls = [];
+    for (const deallocation of deallocations) {
+        calls.push((0, encodeDeallocation_1.encodeForceDeallocateCall)(deallocation, onBehalf));
+    }
+    calls.push((0, viem_1.encodeFunctionData)({
+        abi: blue_sdk_viem_1.vaultV2Abi,
+        functionName: "redeem",
+        args: [redeem.shares, redeem.recipient, onBehalf],
+    }));
+    let tx = {
+        to: vaultAddress,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: blue_sdk_viem_1.vaultV2Abi,
+            functionName: "multicall",
+            args: [calls],
+        }),
+        value: 0n,
+    };
+    if (metadata) {
+        tx = (0, helpers_1.addTransactionMetadata)(tx, metadata);
+    }
+    return (0, morpho_ts_1.deepFreeze)({
+        ...tx,
+        action: {
+            type: "vaultV2ForceRedeem",
+            args: {
+                vault: vaultAddress,
+                deallocations: deallocations.map((d) => ({ ...d })),
+                redeem: {
+                    shares: redeem.shares,
+                    recipient: redeem.recipient,
+                },
+                onBehalf,
+            },
+        },
+    });
+};
+exports.vaultV2ForceRedeem = vaultV2ForceRedeem;

package/lib/actions/vaultV2/forceWithdraw.d.ts

@@ -0,0 +1,40 @@
+import { type Address } from "viem";
+import { type Deallocation, type Metadata, type Transaction, type VaultV2ForceWithdrawAction } from "../../types";
+export interface VaultV2ForceWithdrawParams {
+    vault: {
+        address: Address;
+    };
+    args: {
+        deallocations: readonly Deallocation[];
+        withdraw: {
+            amount: bigint;
+            recipient: Address;
+        };
+        onBehalf: Address;
+    };
+    metadata?: Metadata;
+}
+/**
+ * Prepares a force withdraw transaction for the VaultV2 contract, using VaultV2's native `multicall`.
+ *
+ * This function encodes one or more `forceDeallocate` calls followed by a single `withdraw`,
+ * executed atomically via VaultV2's `multicall`. This allows a user to free liquidity from
+ * adapters other than the liquidity adapter and withdraw the resulting assets in one transaction.
+ *
+ * A penalty is taken from `onBehalf` for each deallocation to discourage allocation manipulations.
+ * The penalty is applied as a share burn where assets are returned to the vault, so the share price
+ * remains stable (except for rounding).
+ *
+ * @param {Object} params - The vault related parameters.
+ * @param {Object} params.vault - The vault related parameters.
+ * @param {Address} params.vault.address - The vault contract address.
+ * @param {Object} params.args - The force withdraw related parameters.
+ * @param {readonly Deallocation[]} params.args.deallocations - The list of deallocations to perform.
+ * @param {Object} params.args.withdraw - The withdraw parameters applied after deallocations.
+ * @param {bigint} params.args.withdraw.amount - The amount of assets to withdraw.
+ * @param {Address} params.args.withdraw.recipient - The recipient of the withdrawn assets.
+ * @param {Address} params.args.onBehalf - The address from which the penalty is taken (share owner).
+ * @param {Metadata} [params.metadata] - Optional analytics metadata to append.
+ * @returns {Readonly<Transaction<VaultV2ForceWithdrawAction>>} The prepared multicall transaction.
+ */
+export declare const vaultV2ForceWithdraw: ({ vault: { address: vaultAddress }, args: { deallocations, withdraw, onBehalf }, metadata, }: VaultV2ForceWithdrawParams) => Readonly<Transaction<VaultV2ForceWithdrawAction>>;

package/lib/actions/vaultV2/forceWithdraw.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vaultV2ForceWithdraw = void 0;
+const blue_sdk_viem_1 = require("@morpho-org/blue-sdk-viem");
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+const viem_1 = require("viem");
+const helpers_1 = require("../../helpers");
+const encodeDeallocation_1 = require("../../helpers/encodeDeallocation");
+const types_1 = require("../../types");
+/**
+ * Prepares a force withdraw transaction for the VaultV2 contract, using VaultV2's native `multicall`.
+ *
+ * This function encodes one or more `forceDeallocate` calls followed by a single `withdraw`,
+ * executed atomically via VaultV2's `multicall`. This allows a user to free liquidity from
+ * adapters other than the liquidity adapter and withdraw the resulting assets in one transaction.
+ *
+ * A penalty is taken from `onBehalf` for each deallocation to discourage allocation manipulations.
+ * The penalty is applied as a share burn where assets are returned to the vault, so the share price
+ * remains stable (except for rounding).
+ *
+ * @param {Object} params - The vault related parameters.
+ * @param {Object} params.vault - The vault related parameters.
+ * @param {Address} params.vault.address - The vault contract address.
+ * @param {Object} params.args - The force withdraw related parameters.
+ * @param {readonly Deallocation[]} params.args.deallocations - The list of deallocations to perform.
+ * @param {Object} params.args.withdraw - The withdraw parameters applied after deallocations.
+ * @param {bigint} params.args.withdraw.amount - The amount of assets to withdraw.
+ * @param {Address} params.args.withdraw.recipient - The recipient of the withdrawn assets.
+ * @param {Address} params.args.onBehalf - The address from which the penalty is taken (share owner).
+ * @param {Metadata} [params.metadata] - Optional analytics metadata to append.
+ * @returns {Readonly<Transaction<VaultV2ForceWithdrawAction>>} The prepared multicall transaction.
+ */
+const vaultV2ForceWithdraw = ({ vault: { address: vaultAddress }, args: { deallocations, withdraw, onBehalf }, metadata, }) => {
+    if (deallocations.length === 0) {
+        throw new types_1.EmptyDeallocationsError(vaultAddress);
+    }
+    if (withdraw.amount <= 0n) {
+        throw new types_1.NonPositiveAssetAmountError(vaultAddress);
+    }
+    const totalDeallocated = deallocations.reduce((sum, d) => sum + d.amount, 0n);
+    if (withdraw.amount < totalDeallocated) {
+        throw new types_1.DeallocationsExceedWithdrawError(vaultAddress, withdraw.amount, totalDeallocated);
+    }
+    const calls = [];
+    for (const deallocation of deallocations) {
+        calls.push((0, encodeDeallocation_1.encodeForceDeallocateCall)(deallocation, onBehalf));
+    }
+    calls.push((0, viem_1.encodeFunctionData)({
+        abi: blue_sdk_viem_1.vaultV2Abi,
+        functionName: "withdraw",
+        args: [withdraw.amount, withdraw.recipient, onBehalf],
+    }));
+    let tx = {
+        to: vaultAddress,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: blue_sdk_viem_1.vaultV2Abi,
+            functionName: "multicall",
+            args: [calls],
+        }),
+        value: 0n,
+    };
+    if (metadata) {
+        tx = (0, helpers_1.addTransactionMetadata)(tx, metadata);
+    }
+    return (0, morpho_ts_1.deepFreeze)({
+        ...tx,
+        action: {
+            type: "vaultV2ForceWithdraw",
+            args: {
+                vault: vaultAddress,
+                deallocations: deallocations.map((d) => ({ ...d })),
+                withdraw: {
+                    amount: withdraw.amount,
+                    recipient: withdraw.recipient,
+                },
+                onBehalf,
+            },
+        },
+    });
+};
+exports.vaultV2ForceWithdraw = vaultV2ForceWithdraw;

package/lib/actions/vaultV2/index.d.ts

@@ -1,3 +1,5 @@
 export * from "./deposit";
+export * from "./forceRedeem";
+export * from "./forceWithdraw";
 export * from "./redeem";
 export * from "./withdraw";

package/lib/actions/vaultV2/index.js

@@ -15,5 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./deposit"), exports);
+__exportStar(require("./forceRedeem"), exports);
+__exportStar(require("./forceWithdraw"), exports);
 __exportStar(require("./redeem"), exports);
 __exportStar(require("./withdraw"), exports);

package/lib/actions/vaultV2/redeem.js

@@ -25,8 +25,8 @@ const types_1 = require("../../types");
  * @returns {Readonly<Transaction<VaultV2RedeemAction>>} The prepared redeem transaction.
  */
 const vaultV2Redeem = ({ vault: { address: vaultAddress }, args: { shares, recipient, onBehalf }, metadata, }) => {
-    if (shares === 0n) {
-        throw new types_1.ZeroSharesAmountError(vaultAddress);
+    if (shares <= 0n) {
+        throw new types_1.NonPositiveSharesAmountError(vaultAddress);
     }
     let tx = {
         to: vaultAddress,

package/lib/actions/vaultV2/withdraw.d.ts

@@ -5,7 +5,7 @@ export interface VaultV2WithdrawParams {
         address: Address;
     };
     args: {
-        assets: bigint;
+        amount: bigint;
         recipient: Address;
         onBehalf: Address;
     };
@@ -23,10 +23,10 @@ export interface VaultV2WithdrawParams {
  * @param {Object} params.vault - The vault related parameters.
  * @param {Address} params.vault.address - The vault address.
  * @param {Object} params.args - The withdraw related parameters.
- * @param {bigint} params.args.assets - The amount of assets to withdraw.
+ * @param {bigint} params.args.amount - The amount of assets to withdraw.
  * @param {Address} params.args.recipient - The recipient address.
  * @param {Address} params.args.onBehalf - The address on behalf of which the withdraw is made.
  * @param {Metadata} [params.metadata] - Optional the metadata.
  * @returns {Readonly<Transaction<VaultV2WithdrawAction>>} The prepared withdraw transaction.
  */
-export declare const vaultV2Withdraw: ({ vault: { address: vaultAddress }, args: { assets, recipient, onBehalf }, metadata, }: VaultV2WithdrawParams) => Readonly<Transaction<VaultV2WithdrawAction>>;
+export declare const vaultV2Withdraw: ({ vault: { address: vaultAddress }, args: { amount, recipient, onBehalf }, metadata, }: VaultV2WithdrawParams) => Readonly<Transaction<VaultV2WithdrawAction>>;

package/lib/actions/vaultV2/withdraw.js

@@ -18,22 +18,22 @@ const types_1 = require("../../types");
  * @param {Object} params.vault - The vault related parameters.
  * @param {Address} params.vault.address - The vault address.
  * @param {Object} params.args - The withdraw related parameters.
- * @param {bigint} params.args.assets - The amount of assets to withdraw.
+ * @param {bigint} params.args.amount - The amount of assets to withdraw.
  * @param {Address} params.args.recipient - The recipient address.
  * @param {Address} params.args.onBehalf - The address on behalf of which the withdraw is made.
  * @param {Metadata} [params.metadata] - Optional the metadata.
  * @returns {Readonly<Transaction<VaultV2WithdrawAction>>} The prepared withdraw transaction.
  */
-const vaultV2Withdraw = ({ vault: { address: vaultAddress }, args: { assets, recipient, onBehalf }, metadata, }) => {
-    if (assets === 0n) {
-        throw new types_1.ZeroAssetAmountError(vaultAddress);
+const vaultV2Withdraw = ({ vault: { address: vaultAddress }, args: { amount, recipient, onBehalf }, metadata, }) => {
+    if (amount <= 0n) {
+        throw new types_1.NonPositiveAssetAmountError(vaultAddress);
     }
     let tx = {
         to: vaultAddress,
         data: (0, viem_1.encodeFunctionData)({
             abi: blue_sdk_viem_1.vaultV2Abi,
             functionName: "withdraw",
-            args: [assets, recipient, onBehalf],
+            args: [amount, recipient, onBehalf],
         }),
         value: 0n,
     };
@@ -44,7 +44,7 @@ const vaultV2Withdraw = ({ vault: { address: vaultAddress }, args: { assets, rec
         ...tx,
         action: {
             type: "vaultV2Withdraw",
-            args: { vault: vaultAddress, assets, recipient },
+            args: { vault: vaultAddress, amount, recipient },
         },
     });
 };

package/lib/client/morphoClient.d.ts

@@ -1,5 +1,5 @@
 import type { Address, Client } from "viem";
-import { MorphoVaultV2 } from "../entities";
+import { MorphoVaultV1, MorphoVaultV2 } from "../entities";
 import type { Metadata, MorphoClientType } from "../types";
 export declare class MorphoClient implements MorphoClientType {
     readonly viemClient: Client;
@@ -18,5 +18,6 @@ export declare class MorphoClient implements MorphoClientType {
         readonly supportDeployless?: boolean;
         readonly metadata?: Metadata;
     } | undefined);
+    vaultV1(vault: Address, chainId: number): MorphoVaultV1;
     vaultV2(vault: Address, chainId: number): MorphoVaultV2;
 }

package/lib/client/morphoClient.js

@@ -15,6 +15,9 @@ class MorphoClient {
             supportDeployless: _options?.supportDeployless,
         };
     }
+    vaultV1(vault, chainId) {
+        return new entities_1.MorphoVaultV1(this, vault, chainId);
+    }
     vaultV2(vault, chainId) {
         return new entities_1.MorphoVaultV2(this, vault, chainId);
     }