@morpho-org/consumer-sdk 0.1.8 → 0.3.0

package/lib/actions/requirements/getRequirementsAction.d.ts

@@ -1,7 +1,10 @@
 import type { Action } from "@morpho-org/bundler-sdk-viem";
-import type { Permit2Action, PermitAction, PermitArgs } from "../../types";
+import { type Address } from "viem";
+import { type Permit2Action, type PermitAction, type PermitArgs } from "../../types";
 interface GetRequirementsActionParams {
     chainId: number;
+    asset: Address;
+    assets: bigint;
     requirementSignature: {
         args: PermitArgs;
         action: PermitAction | Permit2Action;
@@ -10,5 +13,5 @@ interface GetRequirementsActionParams {
 /**
  * Get the actions required to transfer the asset based on the requirement signature.
  */
-export declare const getRequirementsAction: ({ chainId, requirementSignature, }: GetRequirementsActionParams) => Action[];
+export declare const getRequirementsAction: ({ chainId, asset, assets, requirementSignature, }: GetRequirementsActionParams) => Action[];
 export {};

package/lib/actions/requirements/getRequirementsAction.js

@@ -2,10 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRequirementsAction = void 0;
 const blue_sdk_1 = require("@morpho-org/blue-sdk");
+const viem_1 = require("viem");
+const types_1 = require("../../types");
 /**
  * Get the actions required to transfer the asset based on the requirement signature.
  */
-const getRequirementsAction = ({ chainId, requirementSignature, }) => {
+const getRequirementsAction = ({ chainId, asset, assets, requirementSignature, }) => {
+    if (!(0, viem_1.isAddressEqual)(requirementSignature.args.asset, asset)) {
+        throw new types_1.DepositAssetMismatchError(asset, requirementSignature.args.asset);
+    }
+    if (requirementSignature.args.amount !== assets) {
+        throw new types_1.DepositAmountMismatchError(assets, requirementSignature.args.amount);
+    }
     const { bundler3: { generalAdapter1 }, } = (0, blue_sdk_1.getChainAddresses)(chainId);
     if (requirementSignature.action.type === "permit2") {
         if (!("expiration" in requirementSignature.args)) {
@@ -31,12 +39,7 @@ const getRequirementsAction = ({ chainId, requirementSignature, }) => {
             },
             {
                 type: "transferFrom2",
-                args: [
-                    requirementSignature.args.asset,
-                    requirementSignature.args.amount,
-                    generalAdapter1,
-                    false,
-                ],
+                args: [asset, assets, generalAdapter1, false],
             },
         ];
     }
@@ -54,12 +57,7 @@ const getRequirementsAction = ({ chainId, requirementSignature, }) => {
         },
         {
             type: "erc20TransferFrom",
-            args: [
-                requirementSignature.args.asset,
-                requirementSignature.args.amount,
-                generalAdapter1,
-                false,
-            ],
+            args: [asset, assets, generalAdapter1, false],
         },
     ];
 };

package/lib/actions/vaultV2/deposit.js

@@ -45,7 +45,12 @@ const vaultV2Deposit = ({ vault: { chainId, address: vaultAddress, asset }, args
     }
     const actions = [];
     if (requirementSignature) {
-        actions.push(...(0, getRequirementsAction_1.getRequirementsAction)({ chainId, requirementSignature }));
+        actions.push(...(0, getRequirementsAction_1.getRequirementsAction)({
+            chainId,
+            asset,
+            assets,
+            requirementSignature,
+        }));
     }
     else {
         const { bundler3: { generalAdapter1 }, } = (0, blue_sdk_1.getChainAddresses)(chainId);

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.ZeroSharesAmountError(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: {
+            assets: 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.assets - 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.assets - 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.assets === 0n) {
+        throw new types_1.ZeroAssetAmountError(vaultAddress);
+    }
+    const totalDeallocated = deallocations.reduce((sum, d) => sum + d.assets, 0n);
+    if (withdraw.assets < totalDeallocated) {
+        throw new types_1.DeallocationsExceedWithdrawError(vaultAddress, withdraw.assets, 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.assets, 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: {
+                    assets: withdraw.assets,
+                    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/client/morphoViemExtension.d.ts

@@ -6,6 +6,8 @@ import { MorphoClient } from "./morphoClient";
  * Adds `morpho` namespace to viem clients with vaultV2 actions.
  *
  * @param metadata - (Optional) Metadata object that will be passed to all morpho actions. If provided, this metadata can be used for analytics, logging, or to carry additional information with each action.
+ * @param supportSignature - (Optional) Whether to support off-chain signature requirements. If true, the SDK will try to use permit or permit2 if the token supports it.
+ * @param supportDeployless - (Optional) Whether to support deployless mode. If true, the SDK will use the deployless mode to fetch data.
  * @returns Extension function that adds morpho namespace to viem clients
  *
  * @example
@@ -26,8 +28,9 @@ import { MorphoClient } from "./morphoClient";
  * ```
  */
 export declare function morphoViemExtension(_options?: {
-    metadata?: Metadata;
-    supportSignature?: boolean;
+    readonly metadata?: Metadata;
+    readonly supportSignature?: boolean;
+    readonly supportDeployless?: boolean;
 }): <TClient extends Client>(client: TClient) => {
     morpho: MorphoClient;
 };

package/lib/client/morphoViemExtension.js

@@ -7,6 +7,8 @@ const morphoClient_1 = require("./morphoClient");
  * Adds `morpho` namespace to viem clients with vaultV2 actions.
  *
  * @param metadata - (Optional) Metadata object that will be passed to all morpho actions. If provided, this metadata can be used for analytics, logging, or to carry additional information with each action.
+ * @param supportSignature - (Optional) Whether to support off-chain signature requirements. If true, the SDK will try to use permit or permit2 if the token supports it.
+ * @param supportDeployless - (Optional) Whether to support deployless mode. If true, the SDK will use the deployless mode to fetch data.
  * @returns Extension function that adds morpho namespace to viem clients
  *
  * @example

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

@@ -1,15 +1,17 @@
 import { fetchAccrualVaultV2 } from "@morpho-org/blue-sdk-viem";
 import type { Address } from "viem";
-import { type ERC20ApprovalAction, type MorphoClientType, type Requirement, type RequirementSignature, type Transaction, type VaultV2DepositAction, type VaultV2RedeemAction, type VaultV2WithdrawAction } from "../../types";
+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 { FetchParameters } from "../../types/data";
 export interface VaultV2Actions {
     /**
      * Fetches the latest vault data.
      *
      * This function fetches the latest vault data from the blockchain.
+     * @param {FetchParameters} [parameters] - The parameters for the fetch operation.
      *
      * @returns {Promise<Awaited<ReturnType<typeof fetchAccrualVaultV2>>>} The latest vault data.
      */
-    getData: () => Promise<Awaited<ReturnType<typeof fetchAccrualVaultV2>>>;
+    getData: (parameters?: FetchParameters) => Promise<Awaited<ReturnType<typeof fetchAccrualVaultV2>>>;
     /**
      * Prepares a deposit transaction for the VaultV2 contract.
      *
@@ -21,7 +23,7 @@ export interface VaultV2Actions {
      * @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.slippageTolerance=DEFAULT_SLIPPAGE_TOLERANCE] - Optional slippage tolerance value. Default is 0.03%.
+     * @param {bigint} [params.slippageTolerance=DEFAULT_SLIPPAGE_TOLERANCE] - Optional slippage tolerance value. Default is 0.03%. Slippage tolerance must be less than 10%.
      * @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.
@@ -43,7 +45,7 @@ export interface VaultV2Actions {
      *
      * @param {Object} params - The withdraw parameters.
      * @param {bigint} params.assets - The amount of assets to withdraw.
-     * @param {Address} [params.userAddress] - Optional user address initiating the 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.
      */
@@ -60,7 +62,7 @@ export interface VaultV2Actions {
      *
      * @param {Object} params - The redeem parameters.
      * @param {bigint} params.shares - The amount of shares to redeem.
-     * @param {Address} [params.userAddress] - Optional user address initiating the redeem.
+     * @param {Address} params.userAddress - User address initiating the redeem.
      * @returns {Object} The result object.
      * @returns {Readonly<Transaction<VaultV2RedeemAction>>} returns.tx The prepared redeem transaction.
      */
@@ -70,13 +72,68 @@ export interface VaultV2Actions {
     }) => {
         buildTx: () => Readonly<Transaction<VaultV2RedeemAction>>;
     };
+    /**
+     * Prepares a force withdraw transaction for the VaultV2 contract using the vault's native multicall.
+     *
+     * This function encodes one or more on-chain forceDeallocate calls followed by a single withdraw,
+     * executed atomically via VaultV2's multicall. This allows a user to free liquidity from multiple
+     * illiquid markets and withdraw the resulting assets in one transaction.
+     *
+     * @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 {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.
+     */
+    forceWithdraw: (params: {
+        deallocations: readonly Deallocation[];
+        withdraw: {
+            assets: bigint;
+        };
+        userAddress: Address;
+    }) => {
+        buildTx: () => Readonly<Transaction<VaultV2ForceWithdrawAction>>;
+    };
+    /**
+     * Prepares a force redeem transaction for the VaultV2 contract using the vault's native multicall.
+     *
+     * This function encodes one or more on-chain forceDeallocate calls followed by a single redeem,
+     * executed atomically via VaultV2's multicall. This allows a user to free liquidity from multiple
+     * illiquid markets and redeem all their shares in one transaction.
+     *
+     * This is the share-based counterpart to forceWithdraw, useful for maximum withdrawal scenarios
+     * where specifying an exact asset amount is impractical.
+     *
+     * 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.
+     *
+     * @param {Object} params - The force redeem parameters.
+     * @param {readonly Deallocation[]} params.deallocations - The typed list of deallocations to perform.
+     * @param {Object} params.redeem - The redeem parameters applied after deallocations.
+     * @param {bigint} params.redeem.shares - The amount of shares to redeem.
+     * @param {Address} params.userAddress - User address (penalty source and redeem recipient).
+     * @returns {Object} The result object.
+     * @returns {Readonly<Transaction<VaultV2ForceRedeemAction>>} returns.buildTx The prepared multicall transaction.
+     */
+    forceRedeem: (params: {
+        deallocations: readonly Deallocation[];
+        redeem: {
+            shares: bigint;
+        };
+        userAddress: Address;
+    }) => {
+        buildTx: () => Readonly<Transaction<VaultV2ForceRedeemAction>>;
+    };
 }
 export declare class MorphoVaultV2 implements VaultV2Actions {
     private readonly client;
     private readonly vault;
     private readonly chainId;
     constructor(client: MorphoClientType, vault: Address, chainId: number);
-    getData(): Promise<import("@morpho-org/blue-sdk").AccrualVaultV2>;
+    getData(parameters?: FetchParameters): Promise<import("@morpho-org/blue-sdk").AccrualVaultV2>;
     deposit({ assets, userAddress, slippageTolerance, }: {
         assets: bigint;
         userAddress: Address;
@@ -99,4 +156,22 @@ export declare class MorphoVaultV2 implements VaultV2Actions {
     }): {
         buildTx: () => Readonly<Transaction<VaultV2RedeemAction>>;
     };
+    forceWithdraw({ deallocations, withdraw, userAddress, }: {
+        deallocations: readonly Deallocation[];
+        withdraw: {
+            assets: bigint;
+        };
+        userAddress: Address;
+    }): {
+        buildTx: () => Readonly<Transaction<VaultV2ForceWithdrawAction>>;
+    };
+    forceRedeem({ deallocations, redeem, userAddress, }: {
+        deallocations: readonly Deallocation[];
+        redeem: {
+            shares: bigint;
+        };
+        userAddress: Address;
+    }): {
+        buildTx: () => Readonly<Transaction<VaultV2ForceRedeemAction>>;
+    };
 }

package/lib/entities/vaultV2/vaultV2.js

@@ -4,6 +4,7 @@ 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 actions_1 = require("../../actions");
+const constant_1 = require("../../helpers/constant");
 const types_1 = require("../../types");
 class MorphoVaultV2 {
     client;
@@ -14,8 +15,9 @@ class MorphoVaultV2 {
         this.vault = vault;
         this.chainId = chainId;
     }
-    async getData() {
+    async getData(parameters) {
         return (0, blue_sdk_viem_1.fetchAccrualVaultV2)(this.vault, this.client.viemClient, {
+            ...parameters,
             chainId: this.chainId,
             deployless: this.client.options.supportDeployless,
         });
@@ -28,7 +30,14 @@ class MorphoVaultV2 {
             chainId: this.chainId,
             deployless: this.client.options.supportDeployless,
         });
-        const maxSharePrice = blue_sdk_1.MathLib.min(blue_sdk_1.MathLib.mulDivUp(assets, blue_sdk_1.MathLib.wToRay(blue_sdk_1.MathLib.WAD + slippageTolerance), vaultData.toShares(assets)), blue_sdk_1.MathLib.RAY * 100n);
+        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);
+        }
+        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);
         return {
             getRequirements: async (params) => await (0, actions_1.getRequirements)(this.client.viemClient, {
                 address: vaultData.asset,
@@ -58,6 +67,9 @@ class MorphoVaultV2 {
         };
     }
     withdraw({ assets, 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.vaultV2Withdraw)({
                 vault: { address: this.vault },
@@ -71,6 +83,9 @@ class MorphoVaultV2 {
         };
     }
     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.vaultV2Redeem)({
                 vault: { address: this.vault },
@@ -83,5 +98,43 @@ class MorphoVaultV2 {
             }),
         };
     }
+    forceWithdraw({ deallocations, withdraw, 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.vaultV2ForceWithdraw)({
+                vault: { address: this.vault },
+                args: {
+                    deallocations,
+                    withdraw: {
+                        assets: withdraw.assets,
+                        recipient: userAddress,
+                    },
+                    onBehalf: userAddress,
+                },
+                metadata: this.client.options.metadata,
+            }),
+        };
+    }
+    forceRedeem({ deallocations, redeem, 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.vaultV2ForceRedeem)({
+                vault: { address: this.vault },
+                args: {
+                    deallocations,
+                    redeem: {
+                        shares: redeem.shares,
+                        recipient: userAddress,
+                    },
+                    onBehalf: userAddress,
+                },
+                metadata: this.client.options.metadata,
+            }),
+        };
+    }
 }
 exports.MorphoVaultV2 = MorphoVaultV2;

package/lib/helpers/constant.d.ts

@@ -0,0 +1 @@
+export declare const MAX_SLIPPAGE_TOLERANCE: bigint;

package/lib/helpers/constant.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_SLIPPAGE_TOLERANCE = void 0;
+const blue_sdk_1 = require("@morpho-org/blue-sdk");
+exports.MAX_SLIPPAGE_TOLERANCE = blue_sdk_1.MathLib.WAD / 10n;

package/lib/helpers/encodeDeallocation.d.ts

@@ -0,0 +1,10 @@
+import { type Address, type Hex } from "viem";
+import { type Deallocation } from "../types";
+/**
+ * Encodes a single `forceDeallocate` call as ABI-encoded calldata.
+ *
+ * @param deallocation - A deallocation entry.
+ * @param onBehalf - The address from which the penalty is taken (share owner).
+ * @returns The ABI-encoded calldata for `VaultV2.forceDeallocate`.
+ */
+export declare function encodeForceDeallocateCall(deallocation: Deallocation, onBehalf: Address): Hex;

package/lib/helpers/encodeDeallocation.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeForceDeallocateCall = encodeForceDeallocateCall;
+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 types_1 = require("../types");
+/**
+ * Encodes the adapter-specific `data` bytes for a `forceDeallocate` call.
+ *
+ * @param deallocation - A deallocation entry.
+ * @returns The ABI-encoded bytes to pass as `data` to VaultV2.forceDeallocate.
+ */
+function encodeDeallocateData(deallocation) {
+    if (deallocation.marketParams) {
+        return (0, viem_1.encodeAbiParameters)([blue_sdk_1.marketParamsAbi], [deallocation.marketParams]);
+    }
+    return "0x";
+}
+/**
+ * Encodes a single `forceDeallocate` call as ABI-encoded calldata.
+ *
+ * @param deallocation - A deallocation entry.
+ * @param onBehalf - The address from which the penalty is taken (share owner).
+ * @returns The ABI-encoded calldata for `VaultV2.forceDeallocate`.
+ */
+function encodeForceDeallocateCall(deallocation, onBehalf) {
+    if (deallocation.assets === 0n) {
+        throw new types_1.ZeroAssetAmountError(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],
+    });
+}

package/lib/types/action.d.ts

@@ -1,4 +1,5 @@
 import type { Address, Client, Hex } from "viem";
+import type { Deallocation } from "./deallocation";
 export interface BaseAction<TType extends string = string, TArgs extends Record<string, unknown> = Record<string, unknown>> {
     readonly type: TType;
     readonly args: TArgs;
@@ -30,7 +31,27 @@ export interface VaultV2RedeemAction extends BaseAction<"vaultV2Redeem", {
     recipient: Address;
 }> {
 }
-export type TransactionAction = ERC20ApprovalAction | VaultV2DepositAction | VaultV2WithdrawAction | VaultV2RedeemAction;
+export interface VaultV2ForceWithdrawAction extends BaseAction<"vaultV2ForceWithdraw", {
+    vault: Address;
+    deallocations: readonly Deallocation[];
+    withdraw: {
+        assets: bigint;
+        recipient: Address;
+    };
+    onBehalf: Address;
+}> {
+}
+export interface VaultV2ForceRedeemAction extends BaseAction<"vaultV2ForceRedeem", {
+    vault: Address;
+    deallocations: readonly Deallocation[];
+    redeem: {
+        shares: bigint;
+        recipient: Address;
+    };
+    onBehalf: Address;
+}> {
+}
+export type TransactionAction = ERC20ApprovalAction | VaultV2DepositAction | VaultV2WithdrawAction | VaultV2RedeemAction | VaultV2ForceWithdrawAction | VaultV2ForceRedeemAction;
 export interface Transaction<TAction extends BaseAction = TransactionAction> {
     readonly to: Address;
     readonly value: bigint;

package/lib/types/data.d.ts

@@ -0,0 +1,2 @@
+import type { CallParameters, UnionPick } from "viem";
+export type FetchParameters = UnionPick<CallParameters, "account" | "blockNumber" | "blockTag" | "stateOverride">;

package/lib/types/data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/deallocation.d.ts

@@ -0,0 +1,15 @@
+import type { MarketParams } from "@morpho-org/blue-sdk";
+import type { Address } from "viem";
+/**
+ * A single deallocation entry for a `forceDeallocate` call.
+ *
+ * - When `marketParams` is provided, the adapter is treated as a Morpho Market V1 adapter
+ *   and `data` is ABI-encoded from the given `MarketParams`.
+ * - When `marketParams` is omitted, empty bytes are passed as `data` (suitable for adapters
+ *   such as Vault V1 that do not require market identification).
+ */
+export interface Deallocation {
+    readonly adapter: Address;
+    readonly marketParams?: MarketParams;
+    readonly assets: bigint;
+}

package/lib/types/deallocation.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/error.d.ts

@@ -1,6 +1,6 @@
 import type { Address } from "viem";
 export declare class ZeroAssetAmountError extends Error {
-    constructor(asset: Address);
+    constructor(origin: Address);
 }
 export declare class ZeroSharesAmountError extends Error {
     constructor(vault: Address);
@@ -20,3 +20,18 @@ export declare class MissingClientPropertyError extends Error {
 export declare class ApprovalAmountLessThanSpendAmountError extends Error {
     constructor();
 }
+export declare class ExcessiveSlippageToleranceError extends Error {
+    constructor(slippageTolerance: bigint);
+}
+export declare class EmptyDeallocationsError extends Error {
+    constructor(vault: Address);
+}
+export declare class DepositAmountMismatchError extends Error {
+    constructor(depositAmount: bigint, signatureAmount: bigint);
+}
+export declare class DepositAssetMismatchError extends Error {
+    constructor(depositAsset: Address, signatureAsset: Address);
+}
+export declare class DeallocationsExceedWithdrawError extends Error {
+    constructor(vault: Address, withdrawAssets: bigint, totalDeallocated: bigint);
+}

package/lib/types/error.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApprovalAmountLessThanSpendAmountError = exports.MissingClientPropertyError = exports.ChainIdMismatchError = exports.AddressMismatchError = exports.ZeroMaxSharePriceError = exports.ZeroSharesAmountError = exports.ZeroAssetAmountError = void 0;
+exports.DeallocationsExceedWithdrawError = exports.DepositAssetMismatchError = exports.DepositAmountMismatchError = exports.EmptyDeallocationsError = exports.ExcessiveSlippageToleranceError = exports.ApprovalAmountLessThanSpendAmountError = exports.MissingClientPropertyError = exports.ChainIdMismatchError = exports.AddressMismatchError = exports.ZeroMaxSharePriceError = exports.ZeroSharesAmountError = exports.ZeroAssetAmountError = void 0;
 class ZeroAssetAmountError extends Error {
-    constructor(asset) {
-        super(`Asset amount cannot be zero for address: ${asset}`);
+    constructor(origin) {
+        super(`Asset amount cannot be zero for address ${origin}`);
     }
 }
 exports.ZeroAssetAmountError = ZeroAssetAmountError;
@@ -43,3 +43,33 @@ class ApprovalAmountLessThanSpendAmountError extends Error {
     }
 }
 exports.ApprovalAmountLessThanSpendAmountError = ApprovalAmountLessThanSpendAmountError;
+class ExcessiveSlippageToleranceError extends Error {
+    constructor(slippageTolerance) {
+        super(`Slippage tolerance ${slippageTolerance} exceeds maximum allowed (10%)`);
+    }
+}
+exports.ExcessiveSlippageToleranceError = ExcessiveSlippageToleranceError;
+class EmptyDeallocationsError extends Error {
+    constructor(vault) {
+        super(`Deallocations list cannot be empty for vault: ${vault}`);
+    }
+}
+exports.EmptyDeallocationsError = EmptyDeallocationsError;
+class DepositAmountMismatchError extends Error {
+    constructor(depositAmount, signatureAmount) {
+        super(`Deposit amount ${depositAmount} does not match requirement signature amount ${signatureAmount}`);
+    }
+}
+exports.DepositAmountMismatchError = DepositAmountMismatchError;
+class DepositAssetMismatchError extends Error {
+    constructor(depositAsset, signatureAsset) {
+        super(`Deposit asset ${depositAsset} does not match requirement signature asset ${signatureAsset}`);
+    }
+}
+exports.DepositAssetMismatchError = DepositAssetMismatchError;
+class DeallocationsExceedWithdrawError extends Error {
+    constructor(vault, withdrawAssets, totalDeallocated) {
+        super(`Total deallocated assets (${totalDeallocated}) exceed withdraw amount (${withdrawAssets}) for vault: ${vault}`);
+    }
+}
+exports.DeallocationsExceedWithdrawError = DeallocationsExceedWithdrawError;

package/lib/types/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./action";
 export * from "./client";
+export * from "./deallocation";
 export * from "./entity";
 export * from "./error";
 export * from "./metadata";

package/lib/types/index.js

@@ -16,6 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./action"), exports);
 __exportStar(require("./client"), exports);
+__exportStar(require("./deallocation"), exports);
 __exportStar(require("./entity"), exports);
 __exportStar(require("./error"), exports);
 __exportStar(require("./metadata"), exports);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@morpho-org/consumer-sdk",
   "description": "Abstraction layer for Morpho's complexity.",
-  "version": "0.1.8",
+  "version": "0.3.0",
   "author": "Morpho Association <contact@morpho.org>",
   "contributors": [
     "Foulks-Plb <https://x.com/FoulkPlb>"
@@ -20,7 +20,7 @@
   "devDependencies": {
     "@biomejs/biome": "2.3.3",
     "@changesets/cli": "^2.29.8",
-    "@morpho-org/test": "2.6.7",
+    "@morpho-org/test": "2.7.0",
     "@types/node": "^24.9.1",
     "@vitest/coverage-v8": "3.2.4",
     "@vitest/ui": "3.2.4",