@morpho-org/consumer-sdk 0.3.0 → 0.4.0

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

package/lib/entities/vaultV2/vaultV2.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MorphoVaultV2 = void 0;
 const blue_sdk_1 = require("@morpho-org/blue-sdk");
 const blue_sdk_viem_1 = require("@morpho-org/blue-sdk-viem");
+const viem_1 = require("viem");
 const actions_1 = require("../../actions");
 const constant_1 = require("../../helpers/constant");
 const types_1 = require("../../types");
@@ -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,
                 },
@@ -108,7 +131,7 @@ class MorphoVaultV2 {
                 args: {
                     deallocations,
                     withdraw: {
-                        assets: withdraw.assets,
+                        amount: withdraw.amount,
                         recipient: userAddress,
                     },
                     onBehalf: userAddress,

package/lib/helpers/encodeDeallocation.js

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

package/lib/types/action.d.ts

@@ -14,14 +14,15 @@ export interface ERC20PermitAction {
 }
 export interface VaultV2DepositAction extends BaseAction<"vaultV2Deposit", {
     vault: Address;
-    assets: bigint;
+    amount: bigint;
     maxSharePrice: bigint;
     recipient: Address;
+    nativeAmount?: bigint;
 }> {
 }
 export interface VaultV2WithdrawAction extends BaseAction<"vaultV2Withdraw", {
     vault: Address;
-    assets: bigint;
+    amount: bigint;
     recipient: Address;
 }> {
 }
@@ -35,7 +36,7 @@ export interface VaultV2ForceWithdrawAction extends BaseAction<"vaultV2ForceWith
     vault: Address;
     deallocations: readonly Deallocation[];
     withdraw: {
-        assets: bigint;
+        amount: bigint;
         recipient: Address;
     };
     onBehalf: Address;
@@ -51,13 +52,47 @@ export interface VaultV2ForceRedeemAction extends BaseAction<"vaultV2ForceRedeem
     onBehalf: Address;
 }> {
 }
-export type TransactionAction = ERC20ApprovalAction | VaultV2DepositAction | VaultV2WithdrawAction | VaultV2RedeemAction | VaultV2ForceWithdrawAction | VaultV2ForceRedeemAction;
+export interface VaultV1DepositAction extends BaseAction<"vaultV1Deposit", {
+    vault: Address;
+    amount: bigint;
+    maxSharePrice: bigint;
+    recipient: Address;
+    nativeAmount?: bigint;
+}> {
+}
+export interface VaultV1WithdrawAction extends BaseAction<"vaultV1Withdraw", {
+    vault: Address;
+    amount: bigint;
+    recipient: Address;
+}> {
+}
+export interface VaultV1RedeemAction extends BaseAction<"vaultV1Redeem", {
+    vault: Address;
+    shares: bigint;
+    recipient: Address;
+}> {
+}
+export type TransactionAction = ERC20ApprovalAction | VaultV2DepositAction | VaultV2WithdrawAction | VaultV2RedeemAction | VaultV2ForceWithdrawAction | VaultV2ForceRedeemAction | VaultV1DepositAction | VaultV1WithdrawAction | VaultV1RedeemAction;
 export interface Transaction<TAction extends BaseAction = TransactionAction> {
     readonly to: Address;
     readonly value: bigint;
     readonly data: Hex;
     readonly action: TAction;
 }
+/**
+ * Enforces that at least one deposit amount source is provided.
+ *
+ * - `amount` alone: standard ERC20 deposit.
+ * - `nativeAmount` alone: pure native-wrap deposit (vault asset must be wNative).
+ * - Both: mixed deposit (ERC20 transfer + native wrap).
+ */
+export type DepositAmountArgs = {
+    amount: bigint;
+    nativeAmount?: bigint;
+} | {
+    nativeAmount: bigint;
+    amount?: bigint;
+};
 export interface PermitArgs {
     owner: Address;
     nonce: bigint;

package/lib/types/client.d.ts

@@ -1,5 +1,5 @@
 import type { Address, Client } from "viem";
-import type { VaultV2Actions } from "../entities";
+import type { VaultV1Actions, VaultV2Actions } from "../entities";
 import type { Metadata } from "./index";
 export interface MorphoClientType {
     readonly viemClient: Client;
@@ -8,5 +8,6 @@ export interface MorphoClientType {
         readonly supportDeployless?: boolean;
         readonly metadata?: Metadata;
     };
+    vaultV1: (vault: Address, chainId: number) => VaultV1Actions;
     vaultV2: (vault: Address, chainId: number) => VaultV2Actions;
 }

package/lib/types/deallocation.d.ts

@@ -11,5 +11,5 @@ import type { Address } from "viem";
 export interface Deallocation {
     readonly adapter: Address;
     readonly marketParams?: MarketParams;
-    readonly assets: bigint;
+    readonly amount: bigint;
 }

package/lib/types/error.d.ts

@@ -1,11 +1,11 @@
 import type { Address } from "viem";
-export declare class ZeroAssetAmountError extends Error {
+export declare class NonPositiveAssetAmountError extends Error {
     constructor(origin: Address);
 }
-export declare class ZeroSharesAmountError extends Error {
+export declare class NonPositiveSharesAmountError extends Error {
     constructor(vault: Address);
 }
-export declare class ZeroMaxSharePriceError extends Error {
+export declare class NonPositiveMaxSharePriceError extends Error {
     constructor(vault: Address);
 }
 export declare class AddressMismatchError extends Error {
@@ -20,6 +20,9 @@ export declare class MissingClientPropertyError extends Error {
 export declare class ApprovalAmountLessThanSpendAmountError extends Error {
     constructor();
 }
+export declare class NegativeSlippageToleranceError extends Error {
+    constructor(slippageTolerance: bigint);
+}
 export declare class ExcessiveSlippageToleranceError extends Error {
     constructor(slippageTolerance: bigint);
 }
@@ -33,5 +36,20 @@ export declare class DepositAssetMismatchError extends Error {
     constructor(depositAsset: Address, signatureAsset: Address);
 }
 export declare class DeallocationsExceedWithdrawError extends Error {
-    constructor(vault: Address, withdrawAssets: bigint, totalDeallocated: bigint);
+    constructor(vault: Address, withdrawAmount: bigint, totalDeallocated: bigint);
+}
+export declare class NativeAmountOnNonWNativeVaultError extends Error {
+    constructor(vaultAsset: Address, wNative: Address);
+}
+export declare class ChainWNativeMissingError extends Error {
+    constructor(chainId: number);
+}
+export declare class NegativeNativeAmountError extends Error {
+    constructor(nativeAmount: bigint);
+}
+export declare class ZeroDepositAmountError extends Error {
+    constructor(vault: Address);
+}
+export declare class VaultAddressMismatchError extends Error {
+    constructor(vaultAddress: Address, argsVaultAddress: Address);
 }