@morpho-org/consumer-sdk 0.2.0 → 0.4.0

package/lib/client/morphoViemExtension.d.ts

@@ -3,18 +3,18 @@ import type { Metadata } from "../types";
 import { MorphoClient } from "./morphoClient";
 /**
  * Morpho extension for viem clients.
- * Adds `morpho` namespace to viem clients with vaultV2 actions.
+ * Adds `morpho` namespace with `vaultV1` and `vaultV2` accessors.
  *
- * @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
+ * @param metadata - (Optional) Metadata appended to all transactions for analytics.
+ * @param supportSignature - (Optional) Enable off-chain permit/permit2 approvals.
+ * @param supportDeployless - (Optional) Enable deployless reads for on-chain data fetching.
+ * @returns Extension function that adds morpho namespace to viem clients.
  *
  * @example
  * ```ts
  * import { createWalletClient, http } from 'viem';
  * import { mainnet } from 'viem/chains';
- * import { morpho } from '@morpho-org/consumer-sdk';
+ * import { morphoViemExtension } from '@morpho-org/consumer-sdk';
  *
  * const client = createWalletClient({
  *   chain: mainnet,
@@ -22,9 +22,12 @@ import { MorphoClient } from "./morphoClient";
  *   account: '0x...',
  * }).extend(morphoViemExtension());
  *
- * // Use morpho actions
- * const vault = client.morpho.vaultV2('0x...');
- * const deposit = await vault.deposit({ assets: 1000000000000000000n });
+ * // VaultV1 (MetaMorpho)
+ * const vaultV1 = client.morpho.vaultV1('0x...', 1);
+ * const depositV1 = await vaultV1.deposit({ amount: 1000000000000000000n, userAddress: '0x...' });
+ *
+ * // VaultV2
+ * const vaultV2 = client.morpho.vaultV2('0x...', 1);
  * ```
  */
 export declare function morphoViemExtension(_options?: {

package/lib/client/morphoViemExtension.js

@@ -4,18 +4,18 @@ exports.morphoViemExtension = morphoViemExtension;
 const morphoClient_1 = require("./morphoClient");
 /**
  * Morpho extension for viem clients.
- * Adds `morpho` namespace to viem clients with vaultV2 actions.
+ * Adds `morpho` namespace with `vaultV1` and `vaultV2` accessors.
  *
- * @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
+ * @param metadata - (Optional) Metadata appended to all transactions for analytics.
+ * @param supportSignature - (Optional) Enable off-chain permit/permit2 approvals.
+ * @param supportDeployless - (Optional) Enable deployless reads for on-chain data fetching.
+ * @returns Extension function that adds morpho namespace to viem clients.
  *
  * @example
  * ```ts
  * import { createWalletClient, http } from 'viem';
  * import { mainnet } from 'viem/chains';
- * import { morpho } from '@morpho-org/consumer-sdk';
+ * import { morphoViemExtension } from '@morpho-org/consumer-sdk';
  *
  * const client = createWalletClient({
  *   chain: mainnet,
@@ -23,9 +23,12 @@ const morphoClient_1 = require("./morphoClient");
  *   account: '0x...',
  * }).extend(morphoViemExtension());
  *
- * // Use morpho actions
- * const vault = client.morpho.vaultV2('0x...');
- * const deposit = await vault.deposit({ assets: 1000000000000000000n });
+ * // VaultV1 (MetaMorpho)
+ * const vaultV1 = client.morpho.vaultV1('0x...', 1);
+ * const depositV1 = await vaultV1.deposit({ amount: 1000000000000000000n, userAddress: '0x...' });
+ *
+ * // VaultV2
+ * const vaultV2 = client.morpho.vaultV2('0x...', 1);
  * ```
  */
 function morphoViemExtension(_options) {

package/lib/entities/index.d.ts

@@ -1 +1,2 @@
+export * from "./vaultV1";
 export * from "./vaultV2";

package/lib/entities/index.js

@@ -14,4 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./vaultV1"), exports);
 __exportStar(require("./vaultV2"), exports);

package/lib/entities/vaultV1/index.d.ts

@@ -0,0 +1 @@
+export * from "./vaultV1";

package/lib/entities/vaultV1/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./vaultV1"), exports);

package/lib/entities/vaultV1/vaultV1.d.ts

@@ -0,0 +1,95 @@
+import { type AccrualVault } from "@morpho-org/blue-sdk";
+import { fetchAccrualVault } from "@morpho-org/blue-sdk-viem";
+import { type Address } from "viem";
+import { type DepositAmountArgs, type ERC20ApprovalAction, type MorphoClientType, type Requirement, type RequirementSignature, type Transaction, type VaultV1DepositAction, type VaultV1RedeemAction, type VaultV1WithdrawAction } from "../../types";
+import type { FetchParameters } from "../../types/data";
+export interface VaultV1Actions {
+    /**
+     * Fetches the latest vault data with accrued interest.
+     *
+     * @param {FetchParameters} [parameters] - Optional fetch parameters (block number, state overrides, etc.).
+     * @returns {Promise<Awaited<ReturnType<typeof fetchAccrualVault>>>} The latest accrued vault data.
+     */
+    getData: (parameters?: FetchParameters) => Promise<Awaited<ReturnType<typeof fetchAccrualVault>>>;
+    /**
+     * Prepares a deposit into a VaultV1 (MetaMorpho) contract.
+     *
+     * Uses pre-fetched accrual vault data to compute `maxSharePrice` with slippage tolerance,
+     * then returns `buildTx` and `getRequirements` for lazy evaluation.
+     *
+     * @param {Object} params - The deposit parameters.
+     * @param {bigint} params.amount - Amount of assets to deposit.
+     * @param {Address} params.userAddress - User address initiating the deposit.
+     * @param {AccrualVault} params.accrualVault - Pre-fetched vault data with asset address and share conversion.
+     * @param {bigint} [params.slippageTolerance=DEFAULT_SLIPPAGE_TOLERANCE] - Slippage tolerance (default 0.03%, max 10%).
+     * @param {bigint} [params.nativeAmount] - Amount of native ETH to wrap into WETH. Vault asset must be wNative.
+     * @returns {Object} Object with `buildTx` and `getRequirements`.
+     */
+    deposit: (params: {
+        userAddress: Address;
+        accrualVault: AccrualVault;
+        slippageTolerance?: bigint;
+    } & DepositAmountArgs) => {
+        buildTx: (requirementSignature?: RequirementSignature) => Readonly<Transaction<VaultV1DepositAction>>;
+        getRequirements: (params?: {
+            useSimplePermit?: boolean;
+        }) => Promise<(Readonly<Transaction<ERC20ApprovalAction>> | Requirement)[]>;
+    };
+    /**
+     * Prepares a withdraw from a VaultV1 (MetaMorpho) contract.
+     *
+     * @param {Object} params - The withdraw parameters.
+     * @param {bigint} params.amount - Amount of assets to withdraw.
+     * @param {Address} params.userAddress - User address initiating the withdraw.
+     * @returns {Object} Object with `buildTx`.
+     */
+    withdraw: (params: {
+        amount: bigint;
+        userAddress: Address;
+    }) => {
+        buildTx: () => Readonly<Transaction<VaultV1WithdrawAction>>;
+    };
+    /**
+     * Prepares a redeem from a VaultV1 (MetaMorpho) contract.
+     *
+     * @param {Object} params - The redeem parameters.
+     * @param {bigint} params.shares - Amount of shares to redeem.
+     * @param {Address} params.userAddress - User address initiating the redeem.
+     * @returns {Object} Object with `buildTx`.
+     */
+    redeem: (params: {
+        shares: bigint;
+        userAddress: Address;
+    }) => {
+        buildTx: () => Readonly<Transaction<VaultV1RedeemAction>>;
+    };
+}
+export declare class MorphoVaultV1 implements VaultV1Actions {
+    private readonly client;
+    private readonly vault;
+    private readonly chainId;
+    constructor(client: MorphoClientType, vault: Address, chainId: number);
+    getData(parameters?: FetchParameters): Promise<AccrualVault>;
+    deposit({ amount, userAddress, accrualVault, slippageTolerance, nativeAmount, }: {
+        userAddress: Address;
+        accrualVault: AccrualVault;
+        slippageTolerance?: bigint;
+    } & DepositAmountArgs): {
+        getRequirements: (params?: {
+            useSimplePermit?: boolean;
+        }) => Promise<(Requirement | Readonly<Transaction<ERC20ApprovalAction>>)[]>;
+        buildTx: (requirementSignature?: RequirementSignature) => Readonly<Transaction<VaultV1DepositAction>>;
+    };
+    withdraw({ amount, userAddress }: {
+        amount: bigint;
+        userAddress: Address;
+    }): {
+        buildTx: () => Readonly<Transaction<VaultV1WithdrawAction>>;
+    };
+    redeem({ shares, userAddress }: {
+        shares: bigint;
+        userAddress: Address;
+    }): {
+        buildTx: () => Readonly<Transaction<VaultV1RedeemAction>>;
+    };
+}

package/lib/entities/vaultV1/vaultV1.js

@@ -0,0 +1,125 @@
+"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) {
+        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 ERC20ApprovalAction, type MorphoClientType, type Requirement, type RequirementSignature, type Transaction, type VaultV2DepositAction, 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>>;
@@ -72,25 +75,80 @@ 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.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.
+     */
+    forceWithdraw: (params: {
+        deallocations: readonly Deallocation[];
+        withdraw: {
+            amount: 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(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>>;
@@ -101,4 +159,22 @@ export declare class MorphoVaultV2 implements VaultV2Actions {
     }): {
         buildTx: () => Readonly<Transaction<VaultV2RedeemAction>>;
     };
+    forceWithdraw({ deallocations, withdraw, userAddress, }: {
+        deallocations: readonly Deallocation[];
+        withdraw: {
+            amount: 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

@@ -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");
@@ -22,31 +23,52 @@ class MorphoVaultV2 {
             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 +76,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 +97,7 @@ class MorphoVaultV2 {
             buildTx: () => (0, actions_1.vaultV2Withdraw)({
                 vault: { address: this.vault },
                 args: {
-                    assets,
+                    amount,
                     recipient: userAddress,
                     onBehalf: userAddress,
                 },
@@ -98,5 +121,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: {
+                        amount: withdraw.amount,
+                        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;