@morpho-org/consumer-sdk 0.2.0 → 0.4.0

package/README.md

@@ -1,4 +1,4 @@
-# Consumer sdk
+# Consumer SDK
 
 ![Beta](https://img.shields.io/badge/status-beta-orange)
 
@@ -6,82 +6,216 @@
 
 > **The abstraction layer that simplifies Morpho protocol**
 
-## ✨ How to use it? (two ways to build transactions)
+## Entities & Actions
 
-### 1️⃣ **With MorphoClient**
+| Entity      | Action          | Route                     | Why                                                                                     |
+| ----------- | --------------- | ------------------------- | --------------------------------------------------------------------------------------- |
+| **VaultV2** | `deposit`       | Bundler (general adapter) | Enforces `maxSharePrice` — inflation attack prevention. Supports native token wrapping. |
+|             | `withdraw`      | Direct vault call         | No attack surface, no bundler overhead needed                                           |
+|             | `redeem`        | Direct vault call         | No attack surface, no bundler overhead needed                                           |
+|             | `forceWithdraw` | Vault `multicall`         | N `forceDeallocate` + 1 `withdraw` in a single tx                                       |
+|             | `forceRedeem`   | Vault `multicall`         | N `forceDeallocate` + 1 `redeem` in a single tx                                         |
+| **VaultV1** | `deposit`       | Bundler (general adapter) | Same ERC-4626 inflation attack prevention as V2. Supports native token wrapping.        |
+|             | `withdraw`      | Direct vault call         | No attack surface                                                                       |
+|             | `redeem`        | Direct vault call         | No attack surface                                                                       |
+
+## VaultV2
 
 ```typescript
 import { MorphoClient } from "@morpho-org/consumer-sdk";
-import { createWalletClient, http } from "viem";
+import { createPublicClient, http } from "viem";
+import { mainnet } from "viem/chains";
+
+const viemClient = createPublicClient({ chain: mainnet, transport: http() });
+const morpho = new MorphoClient(viemClient);
+
+const vault = morpho.vaultV2("0xVault...", 1);
+```
+
+### Deposit
+
+```typescript
+const { buildTx, getRequirements } = await vault.deposit({
+  amount: 1000000000000000000n,
+  userAddress: "0xUser...",
+});
+
+const requirements = await getRequirements();
+const tx = buildTx(requirementSignature);
+```
+
+#### Deposit with native token wrapping
+
+For vaults whose underlying asset is wNative, you can deposit native token that will be automatically wrapped:
+
+```typescript
+// Native ETH only — wraps 1 ETH to WETH and deposits
+const { buildTx, getRequirements } = await vault.deposit({
+  nativeAmount: 1000000000000000000n,
+  userAddress: "0xUser...",
+});
+
+// Mixed — 0.5 WETH (ERC-20) + 0.5 native ETH wrapped to WETH
+const { buildTx, getRequirements } = await vault.deposit({
+  amount: 500000000000000000n,
+  nativeAmount: 500000000000000000n,
+  userAddress: "0xUser...",
+});
+```
+
+The bundler atomically transfers native token, wraps it to wNative, and deposits alongside any ERC-20 amount. The transaction's `value` field is set to `nativeAmount`.
+
+### Withdraw
+
+```typescript
+const { buildTx } = vault.withdraw({
+  amount: 500000000000000000n,
+  userAddress: "0xUser...",
+});
+
+const tx = buildTx();
+```
+
+### Redeem
 
-const client = createWalletClient({
-  chain: mainnet,
-  transport: http(),
-  account: "0x...",
+```typescript
+const { buildTx } = vault.redeem({
+  shares: 1000000000000000000n,
+  userAddress: "0xUser...",
 });
 
-const morpho = new MorphoClient(client);
+const tx = buildTx();
+```
+
+### Force Withdraw
 
-const vault = morpho.vaultV2("0x1234...", 1); // vault address, chain ID
-const deposit = await vault.deposit({
-  assets: 1000000000000000000n, // vault asset amount
-  userAddress: "0x1234...", // recipient address
+```typescript
+const { buildTx } = vault.forceWithdraw({
+  deallocations: [{ adapter: "0xAdapter...", amount: 100n }],
+  withdraw: { amount: 500000000000000000n },
+  userAddress: "0xUser...",
 });
-console.log(deposit.buildTx());
-console.log(await deposit.getRequirements());
 
-const withdraw = vault.withdraw({
-  assets: 1000000000000000000n, // vault asset amount
-  userAddress: "0x1234...", // recipient address
+const tx = buildTx();
+```
+
+### Force Redeem
+
+```typescript
+const { buildTx } = vault.forceRedeem({
+  deallocations: [{ adapter: "0xAdapter...", amount: 100n }],
+  redeem: { shares: 1000000000000000000n },
+  userAddress: "0xUser...",
+});
+
+const tx = buildTx();
+```
+
+## VaultV1
+
+```typescript
+const vault = morpho.vaultV1("0xVault...", 1);
+```
+
+### Deposit
+
+```typescript
+const { buildTx, getRequirements } = await vault.deposit({
+  amount: 1000000000000000000n,
+  userAddress: "0xUser...",
 });
-console.log(withdraw.buildTx());
 
-const redeem = vault.redeem({
-  shares: 1000000000000000000n, // vault shares amount
-  userAddress: "0x1234...", // recipient address
+const requirements = await getRequirements();
+const tx = buildTx(requirementSignature);
+```
+
+### Withdraw
+
+```typescript
+const { buildTx } = vault.withdraw({
+  amount: 500000000000000000n,
+  userAddress: "0xUser...",
 });
-console.log(redeem.buildTx());
+
+const tx = buildTx();
 ```
 
-### 2️⃣ **Direct construction** (Full control)
+### Redeem
 
 ```typescript
-import { vaultV2Deposit } from "@morpho-org/consumer-sdk";
-
-const deposit = vaultV2Deposit({
-  vault: {
-    chainId: mainnet.id,
-    address: "0x1234...", // vault address
-    asset: "0x1234...", // asset address
-  },
-  args: {
-    assets: 1000000000000000000n, // vault asset amount
-    maxSharePrice: 995180497664595699494513674403n,
-    recipient: "0x1234...", // recipient address
-  },
+const { buildTx } = vault.redeem({
+  shares: 1000000000000000000n,
+  userAddress: "0xUser...",
 });
+
+const tx = buildTx();
 ```
 
-## Link Integration - Local Development Guide
+## Architecture
+
+```mermaid
+graph LR
+    MC[MorphoClient]
+
+    MC -->|.vaultV1| MV1
+    MC -->|.vaultV2| MV2
+
+    subgraph VaultV1 Flow
+        MV1[MorphoVaultV1]
+        MV1 --> V1D[vaultV1Deposit]
+        MV1 --> V1W[vaultV1Withdraw]
+        MV1 --> V1R[vaultV1Redeem]
+
+        V1D -->|nativeTransfer + wrapNative + erc4626Deposit| B1[Bundler3]
+        V1W -->|direct call| MM[MetaMorpho]
+        V1R -->|direct call| MM
+    end
+
+    subgraph VaultV2 Flow
+        MV2[MorphoVaultV2]
+        MV2 --> V2D[vaultV2Deposit]
+        MV2 --> V2W[vaultV2Withdraw]
+        MV2 --> V2R[vaultV2Redeem]
+        MV2 --> V2FW[vaultV2ForceWithdraw]
+        MV2 --> V2FR[vaultV2ForceRedeem]
+
+        V2D -->|nativeTransfer + wrapNative + erc4626Deposit| B2[Bundler3]
+        V2W -->|direct call| V2C[VaultV2 Contract]
+        V2R -->|direct call| V2C
+        V2FW -->|multicall| V2C
+        V2FR -->|multicall| V2C
+    end
+
+    subgraph Shared
+        REQ[getRequirements]
+    end
+
+    MV1 -.->|approval / permit| REQ
+    MV2 -.->|approval / permit| REQ
+
+    style B1 fill:#e8f5e9,stroke:#4caf50
+    style B2 fill:#e8f5e9,stroke:#4caf50
+    style MM fill:#fff3e0,stroke:#ff9800
+    style V2C fill:#e3f2fd,stroke:#2196f3
+    style REQ fill:#f3e5f5,stroke:#9c27b0
+```
 
-This guide explains how to link this local package to your Next.js application for easier debugging.
+## Local Development
 
-### **Step 1: Initial setup (one time only)**
+Link this package to your app for local debugging:
 
 ```bash
 # In this consumer-sdk project
 pnpm run build:link
 ```
 
-### **Step 2: In your other project**
+In your other project:
 
 ```bash
 # Link the local package
 pnpm link consumer-sdk
 ```
 
-## 🤝 Contributing
+## Contributing
 
 Contributions are welcome! Feel free to open an issue or PR.
-
-**Made with ❤️ by the Morpho team**

package/lib/actions/index.d.ts

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

package/lib/actions/index.js

@@ -15,4 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./requirements"), exports);
+__exportStar(require("./vaultV1"), exports);
 __exportStar(require("./vaultV2"), exports);

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/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>>;