@morpho-org/consumer-sdk 0.3.0 → 0.5.0

package/lib/actions/requirements/getMorphoAuthorizationRequirement.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMorphoAuthorizationRequirement = void 0;
+const blue_sdk_1 = require("@morpho-org/blue-sdk");
+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 types_1 = require("../../types");
+/**
+ * Checks whether GeneralAdapter1 is authorized on Morpho for the given user.
+ * If not authorized, returns a deep-frozen `morpho.setAuthorization(generalAdapter1, true)` transaction.
+ * Returns `null` if authorization is already in place.
+ *
+ * Required before any bundled borrow on behalf of the user (e.g. `supplyCollateralBorrow`).
+ *
+ * @param params - Request parameters.
+ * @param params.viemClient - Connected viem client.
+ * @param params.chainId - Target chain ID (used to look up Morpho and GeneralAdapter1 addresses).
+ * @param params.userAddress - The user who needs to authorize GeneralAdapter1.
+ * @returns Deep-frozen authorization transaction, or `null` if already authorized.
+ */
+const getMorphoAuthorizationRequirement = async (params) => {
+    const { viemClient, chainId, userAddress } = params;
+    if (viemClient.chain?.id !== chainId) {
+        throw new types_1.ChainIdMismatchError(viemClient.chain?.id, chainId);
+    }
+    const { morpho, bundler3: { generalAdapter1 }, } = (0, blue_sdk_1.getChainAddresses)(chainId);
+    const pc = viemClient.extend(viem_1.publicActions);
+    const isAuthorized = await pc.readContract({
+        address: morpho,
+        abi: blue_sdk_viem_1.blueAbi,
+        functionName: "isAuthorized",
+        args: [userAddress, generalAdapter1],
+    });
+    if (isAuthorized) {
+        return null;
+    }
+    return (0, morpho_ts_1.deepFreeze)({
+        to: morpho,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: blue_sdk_viem_1.blueAbi,
+            functionName: "setAuthorization",
+            args: [generalAdapter1, true],
+        }),
+        value: 0n,
+        action: {
+            type: "morphoAuthorization",
+            args: {
+                authorized: generalAdapter1,
+                isAuthorized: true,
+            },
+        },
+    });
+};
+exports.getMorphoAuthorizationRequirement = getMorphoAuthorizationRequirement;

package/lib/actions/requirements/getRequirements.js

@@ -32,6 +32,9 @@ const getRequirements = async (viemClient, params) => {
     if (viemClient.chain?.id !== chainId) {
         throw new types_1.ChainIdMismatchError(viemClient.chain?.id, chainId);
     }
+    if (amount === 0n) {
+        return [];
+    }
     const { permit2, dai, bundler3: { generalAdapter1 }, } = (0, blue_sdk_1.getChainAddresses)(chainId);
     const { erc20Allowances, erc2612Nonce, permit2BundlerAllowance } = await (0, blue_sdk_viem_1.fetchHolding)(from, address, viemClient, {
         deployless: params.supportDeployless,

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

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

package/lib/actions/requirements/getRequirementsAction.js

@@ -7,12 +7,12 @@ const types_1 = require("../../types");
 /**
  * Get the actions required to transfer the asset based on the requirement signature.
  */
-const getRequirementsAction = ({ chainId, asset, assets, requirementSignature, }) => {
+const getRequirementsAction = ({ chainId, asset, amount, 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);
+    if (requirementSignature.args.amount !== amount) {
+        throw new types_1.DepositAmountMismatchError(amount, requirementSignature.args.amount);
     }
     const { bundler3: { generalAdapter1 }, } = (0, blue_sdk_1.getChainAddresses)(chainId);
     if (requirementSignature.action.type === "permit2") {
@@ -34,12 +34,12 @@ const getRequirementsAction = ({ chainId, asset, assets, requirementSignature, }
                         sigDeadline: requirementSignature.args.deadline,
                     },
                     requirementSignature.args.signature,
-                    false,
+                    false /* skipRevert */,
                 ],
             },
             {
                 type: "transferFrom2",
-                args: [asset, assets, generalAdapter1, false],
+                args: [asset, amount, generalAdapter1, false /* skipRevert */],
             },
         ];
     }
@@ -52,12 +52,12 @@ const getRequirementsAction = ({ chainId, asset, assets, requirementSignature, }
                 requirementSignature.args.amount,
                 requirementSignature.args.deadline,
                 requirementSignature.args.signature,
-                false,
+                false /* skipRevert */,
             ],
         },
         {
             type: "erc20TransferFrom",
-            args: [asset, assets, generalAdapter1, false],
+            args: [asset, amount, generalAdapter1, false /* skipRevert */],
         },
     ];
 };

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

@@ -1,4 +1,5 @@
 export * from "./encode/index";
+export * from "./getMorphoAuthorizationRequirement";
 export * from "./getRequirements";
 export * from "./getRequirementsApproval";
 export * from "./getRequirementsPermit";

package/lib/actions/requirements/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./encode/index"), exports);
+__exportStar(require("./getMorphoAuthorizationRequirement"), exports);
 __exportStar(require("./getRequirements"), exports);
 __exportStar(require("./getRequirementsApproval"), exports);
 __exportStar(require("./getRequirementsPermit"), exports);

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

@@ -0,0 +1,41 @@
+import { type Address } from "viem";
+import { type DepositAmountArgs, type Metadata, type RequirementSignature, type Transaction, type VaultV1DepositAction } from "../../types";
+export interface VaultV1DepositParams {
+    vault: {
+        chainId: number;
+        address: Address;
+        asset: Address;
+    };
+    args: DepositAmountArgs & {
+        maxSharePrice: bigint;
+        recipient: Address;
+        requirementSignature?: RequirementSignature;
+    };
+    metadata?: Metadata;
+}
+/**
+ * Prepares a deposit transaction for a VaultV1 (MetaMorpho) contract.
+ *
+ * Routed through the bundler to atomically execute the asset transfer and vault deposit.
+ * The general adapter enforces `maxSharePrice` on-chain to prevent inflation attacks.
+ * Never bypass the general adapter.
+ *
+ * When `nativeAmount` is provided, that amount of native ETH is sent as `msg.value`
+ * to the Bundler3 multicall and wrapped into WETH via `GeneralAdapter1.wrapNative()`.
+ * The vault's underlying asset must be the chain's wrapped native token (wNative).
+ *
+ * @param {Object} params - The deposit parameters.
+ * @param {Object} params.vault - The vault identifiers.
+ * @param {number} params.vault.chainId - The chain ID.
+ * @param {Address} params.vault.address - The vault address.
+ * @param {Address} params.vault.asset - The underlying ERC20 asset address.
+ * @param {Object} params.args - The deposit arguments.
+ * @param {bigint} [params.args.amount=0n] - Amount of ERC-20 assets to deposit. At least one of amount or nativeAmount must be provided.
+ * @param {bigint} params.args.maxSharePrice - Maximum acceptable share price (slippage protection).
+ * @param {Address} params.args.recipient - Receives the vault shares.
+ * @param {RequirementSignature} [params.args.requirementSignature] - Pre-signed permit/permit2 approval.
+ * @param {bigint} [params.args.nativeAmount] - Amount of native token to wrap into wNative for the deposit.
+ * @param {Metadata} [params.metadata] - Optional analytics metadata.
+ * @returns {Readonly<Transaction<VaultV1DepositAction>>} The prepared deposit transaction.
+ */
+export declare const vaultV1Deposit: ({ vault: { chainId, address: vaultAddress, asset }, args: { amount, maxSharePrice, recipient, requirementSignature, nativeAmount, }, metadata, }: VaultV1DepositParams) => Readonly<Transaction<VaultV1DepositAction>>;

package/lib/actions/vaultV1/deposit.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vaultV1Deposit = void 0;
+const blue_sdk_1 = require("@morpho-org/blue-sdk");
+const bundler_sdk_viem_1 = require("@morpho-org/bundler-sdk-viem");
+const morpho_ts_1 = require("@morpho-org/morpho-ts");
+const viem_1 = require("viem");
+const helpers_1 = require("../../helpers");
+const types_1 = require("../../types");
+const getRequirementsAction_1 = require("../requirements/getRequirementsAction");
+/**
+ * Prepares a deposit transaction for a VaultV1 (MetaMorpho) contract.
+ *
+ * Routed through the bundler to atomically execute the asset transfer and vault deposit.
+ * The general adapter enforces `maxSharePrice` on-chain to prevent inflation attacks.
+ * Never bypass the general adapter.
+ *
+ * When `nativeAmount` is provided, that amount of native ETH is sent as `msg.value`
+ * to the Bundler3 multicall and wrapped into WETH via `GeneralAdapter1.wrapNative()`.
+ * The vault's underlying asset must be the chain's wrapped native token (wNative).
+ *
+ * @param {Object} params - The deposit parameters.
+ * @param {Object} params.vault - The vault identifiers.
+ * @param {number} params.vault.chainId - The chain ID.
+ * @param {Address} params.vault.address - The vault address.
+ * @param {Address} params.vault.asset - The underlying ERC20 asset address.
+ * @param {Object} params.args - The deposit arguments.
+ * @param {bigint} [params.args.amount=0n] - Amount of ERC-20 assets to deposit. At least one of amount or nativeAmount must be provided.
+ * @param {bigint} params.args.maxSharePrice - Maximum acceptable share price (slippage protection).
+ * @param {Address} params.args.recipient - Receives the vault shares.
+ * @param {RequirementSignature} [params.args.requirementSignature] - Pre-signed permit/permit2 approval.
+ * @param {bigint} [params.args.nativeAmount] - Amount of native token to wrap into wNative for the deposit.
+ * @param {Metadata} [params.metadata] - Optional analytics metadata.
+ * @returns {Readonly<Transaction<VaultV1DepositAction>>} The prepared deposit transaction.
+ */
+const vaultV1Deposit = ({ vault: { chainId, address: vaultAddress, asset }, args: { amount = 0n, maxSharePrice, recipient, requirementSignature, nativeAmount, }, metadata, }) => {
+    if (amount < 0n) {
+        throw new types_1.NonPositiveAssetAmountError(asset);
+    }
+    if (maxSharePrice <= 0n) {
+        throw new types_1.NonPositiveMaxSharePriceError(vaultAddress);
+    }
+    const actions = [];
+    const { bundler3: { generalAdapter1, bundler3 }, wNative, } = (0, blue_sdk_1.getChainAddresses)(chainId);
+    if (nativeAmount) {
+        if (nativeAmount < 0n) {
+            throw new types_1.NegativeNativeAmountError(nativeAmount);
+        }
+        if (!(0, morpho_ts_1.isDefined)(wNative)) {
+            throw new types_1.ChainWNativeMissingError(chainId);
+        }
+        if (!(0, viem_1.isAddressEqual)(asset, wNative)) {
+            throw new types_1.NativeAmountOnNonWNativeVaultError(asset, wNative);
+        }
+        actions.push(
+        // Transfers native token from Bundler3 to GeneralAdapter1 for wrapping.
+        {
+            type: "nativeTransfer",
+            args: [bundler3, generalAdapter1, nativeAmount, false /* skipRevert */],
+        }, {
+            type: "wrapNative",
+            args: [nativeAmount, generalAdapter1, false /* skipRevert */],
+        });
+    }
+    if (amount > 0n) {
+        if (requirementSignature) {
+            actions.push(...(0, getRequirementsAction_1.getRequirementsAction)({
+                chainId,
+                asset,
+                amount,
+                requirementSignature,
+            }));
+        }
+        else {
+            actions.push({
+                type: "erc20TransferFrom",
+                args: [asset, amount, generalAdapter1, false /* skipRevert */],
+            });
+        }
+    }
+    const totalAssets = amount + (nativeAmount ?? 0n);
+    if (totalAssets === 0n) {
+        throw new types_1.ZeroDepositAmountError(vaultAddress);
+    }
+    actions.push({
+        type: "erc4626Deposit",
+        args: [
+            vaultAddress,
+            totalAssets,
+            maxSharePrice,
+            recipient,
+            false /* skipRevert */,
+        ],
+    });
+    let tx = bundler_sdk_viem_1.BundlerAction.encodeBundle(chainId, actions);
+    if (nativeAmount) {
+        tx = { ...tx, value: nativeAmount };
+    }
+    if (metadata) {
+        tx = (0, helpers_1.addTransactionMetadata)(tx, metadata);
+    }
+    return (0, morpho_ts_1.deepFreeze)({
+        ...tx,
+        action: {
+            type: "vaultV1Deposit",
+            args: {
+                vault: vaultAddress,
+                amount,
+                maxSharePrice,
+                recipient,
+                nativeAmount,
+            },
+        },
+    });
+};
+exports.vaultV1Deposit = vaultV1Deposit;

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

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

package/lib/actions/vaultV1/index.js

@@ -0,0 +1,19 @@
+"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("./deposit"), exports);
+__exportStar(require("./redeem"), exports);
+__exportStar(require("./withdraw"), exports);

package/lib/actions/vaultV1/redeem.d.ts

@@ -0,0 +1,29 @@
+import { type Address } from "viem";
+import { type Metadata, type Transaction, type VaultV1RedeemAction } from "../../types";
+export interface VaultV1RedeemParams {
+    vault: {
+        address: Address;
+    };
+    args: {
+        shares: bigint;
+        recipient: Address;
+        onBehalf: Address;
+    };
+    metadata?: Metadata;
+}
+/**
+ * Prepares a redeem transaction for a VaultV1 (MetaMorpho) contract.
+ *
+ * Direct vault call — no bundler needed. Redeem has no inflation attack surface.
+ *
+ * @param {Object} params - The redeem parameters.
+ * @param {Object} params.vault - The vault identifiers.
+ * @param {Address} params.vault.address - The vault address.
+ * @param {Object} params.args - The redeem arguments.
+ * @param {bigint} params.args.shares - Amount of shares to redeem.
+ * @param {Address} params.args.recipient - Receives the redeemed assets.
+ * @param {Address} params.args.onBehalf - Address whose shares are burned.
+ * @param {Metadata} [params.metadata] - Optional analytics metadata.
+ * @returns {Readonly<Transaction<VaultV1RedeemAction>>} The prepared redeem transaction.
+ */
+export declare const vaultV1Redeem: ({ vault: { address: vaultAddress }, args: { shares, recipient, onBehalf }, metadata, }: VaultV1RedeemParams) => Readonly<Transaction<VaultV1RedeemAction>>;

package/lib/actions/vaultV1/redeem.js

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

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

@@ -0,0 +1,29 @@
+import { type Address } from "viem";
+import { type Metadata, type Transaction, type VaultV1WithdrawAction } from "../../types";
+export interface VaultV1WithdrawParams {
+    vault: {
+        address: Address;
+    };
+    args: {
+        amount: bigint;
+        recipient: Address;
+        onBehalf: Address;
+    };
+    metadata?: Metadata;
+}
+/**
+ * Prepares a withdraw transaction for a VaultV1 (MetaMorpho) contract.
+ *
+ * Direct vault call — no bundler needed. Withdraw has no inflation attack surface.
+ *
+ * @param {Object} params - The withdraw parameters.
+ * @param {Object} params.vault - The vault identifiers.
+ * @param {Address} params.vault.address - The vault address.
+ * @param {Object} params.args - The withdraw arguments.
+ * @param {bigint} params.args.amount - Amount of assets to withdraw.
+ * @param {Address} params.args.recipient - Receives the withdrawn assets.
+ * @param {Address} params.args.onBehalf - Address whose shares are burned.
+ * @param {Metadata} [params.metadata] - Optional analytics metadata.
+ * @returns {Readonly<Transaction<VaultV1WithdrawAction>>} The prepared withdraw transaction.
+ */
+export declare const vaultV1Withdraw: ({ vault: { address: vaultAddress }, args: { amount, recipient, onBehalf }, metadata, }: VaultV1WithdrawParams) => Readonly<Transaction<VaultV1WithdrawAction>>;

package/lib/actions/vaultV1/withdraw.js

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

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

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